Struct Config 

pub struct Config {
    pub mode: Mode,
    pub protocol: Protocol,
    pub port: u16,
    pub server_addr: Option<String>,
    pub bind_addr: Option<IpAddr>,
    pub duration: Duration,
    pub bandwidth: Option<u64>,
    pub buffer_size: usize,
    pub parallel: usize,
    pub reverse: bool,
    pub json: bool,
    pub interval: Duration,
}

Configuration for rperf3 network performance tests.

This structure holds all configuration parameters for both client and server modes. Use the builder pattern methods to customize the configuration.

Examples

Basic TCP Client

use rperf3::Config;
use std::time::Duration;

let config = Config::client("192.168.1.100".to_string(), 5201)
    .with_duration(Duration::from_secs(30))
    .with_buffer_size(256 * 1024); // 256 KB buffer

UDP Client with Bandwidth Limit

use rperf3::{Config, Protocol};
use std::time::Duration;

let config = Config::client("192.168.1.100".to_string(), 5201)
    .with_protocol(Protocol::Udp)
    .with_bandwidth(100_000_000) // 100 Mbps
    .with_duration(Duration::from_secs(10));

Server Configuration

use rperf3::Config;

let config = Config::server(5201);

Reverse Mode Test

use rperf3::Config;
use std::time::Duration;

// Server sends data, client receives
let config = Config::client("192.168.1.100".to_string(), 5201)
    .with_reverse(true)
    .with_duration(Duration::from_secs(10));

Fields

mode: Mode

Server mode or client mode

protocol: Protocol

Protocol to use (TCP or UDP)

port: u16

Port number to use

server_addr: Option<String>

Server address (for client mode)

bind_addr: Option<IpAddr>

Bind address (for server mode)

duration: Duration

Test duration in seconds

bandwidth: Option<u64>

Target bandwidth in bits per second (for UDP)

buffer_size: usize

Buffer size in bytes

parallel: usize

Number of parallel streams

reverse: bool

Reverse mode (server sends, client receives)

json: bool

Output in JSON format

interval: Duration

Interval for periodic bandwidth reports in seconds

Implementations

impl Config

pub fn new() -> Self

Creates a new configuration with default values.

This is equivalent to calling Config::default(). The default configuration is set up for client mode with TCP protocol.

Examples

use rperf3::Config;

let config = Config::new();
assert_eq!(config.port, 5201);

pub fn server(port: u16) -> Self

Creates a new server configuration.

Sets up the configuration for server mode, which listens for incoming connections on the specified port.

Arguments

• port - The port number to listen on (typically 5201)

Examples

use rperf3::Config;

let config = Config::server(5201);

Examples found in repository

examples/server.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Starting rperf3 server on port 5201...");

    let config = Config::server(5201).with_protocol(Protocol::Tcp);

    let server = Server::new(config);
    server.run().await?;

    Ok(())
}

examples/cancellable_test.rs (line 34)

async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
    println!("Starting TCP server on port 5201...");
    println!("Press Ctrl+C to stop the server gracefully.\n");

    let config = Config::server(5201);
    let server = Server::new(config);

    // Clone the cancellation token to handle CTRL+C
    let cancel_token = server.cancellation_token().clone();

    // Set up CTRL+C handler
    tokio::spawn(async move {
        tokio::signal::ctrl_c()
            .await
            .expect("Failed to listen for CTRL+C");
        println!("\nReceived CTRL+C, shutting down server gracefully...");
        cancel_token.cancel();
    });

    server.run().await?;
    println!("Server stopped.");
    Ok(())
}

examples/tcp_nodelay_test.rs (line 29)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("TCP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests TCP with:");
    println!("- TCP_NODELAY enabled (Nagle's algorithm disabled)");
    println!("- 256KB send/receive buffers");
    println!("- Expected 10-20% improvement over default settings\n");

    // Start server in background
    let server_config = Config::server(5201).with_protocol(Protocol::Tcp);
    let server = Server::new(server_config);

    // Run server in background task
    tokio::spawn(async move {
        if let Err(e) = server.run().await {
            eprintln!("Server error: {}", e);
        }
    });

    // Give server time to start
    time::sleep(Duration::from_millis(100)).await;

    println!("Starting TCP test (5 seconds)...\n");

    // Run client test
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1));

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("\nSocket optimizations applied:");
    println!("✓ TCP_NODELAY: enabled");
    println!("✓ Send buffer: 256KB");
    println!("✓ Recv buffer: 256KB");

    Ok(())
}

examples/test_retransmits.rs (line 23)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let args: Vec<String> = std::env::args().collect();
    let mode = args.get(1).map(|s| s.as_str()).unwrap_or("client");

    match mode {
        "server" => {
            println!("Starting TCP server on port 5201...");
            println!("Retransmits will be shown if they occur during the test.\n");

            let config = Config::server(5201);
            let server = Server::new(config);
            server.run().await?;
        }
        "client" => {
            println!("Starting TCP client test (10 seconds)...");
            println!("Retransmits will be tracked and displayed per interval.\n");

            let config = Config::client("127.0.0.1".to_string(), 5201)
                .with_duration(Duration::from_secs(10));

            let client = Client::new(config)?.with_callback(|event: ProgressEvent| match event {
                ProgressEvent::TestStarted => {
                    println!("Test started");
                }
                ProgressEvent::IntervalUpdate {
                    interval_start,
                    interval_end,
                    bits_per_second,
                    retransmits,
                    ..
                } => {
                    if let Some(retrans) = retransmits {
                        println!(
                            "[{:.1}-{:.1}s] {:.2} Mbps  - {} retransmits detected",
                            interval_start.as_secs_f64(),
                            interval_end.as_secs_f64(),
                            bits_per_second / 1_000_000.0,
                            retrans
                        );
                    } else {
                        println!(
                            "[{:.1}-{:.1}s] {:.2} Mbps  - no retransmits",
                            interval_start.as_secs_f64(),
                            interval_end.as_secs_f64(),
                            bits_per_second / 1_000_000.0
                        );
                    }
                }
                ProgressEvent::TestCompleted {
                    total_bytes,
                    bits_per_second,
                    ..
                } => {
                    println!("\nTest completed:");
                    println!("  Total bytes: {}", total_bytes);
                    println!(
                        "  Average throughput: {:.2} Mbps",
                        bits_per_second / 1_000_000.0
                    );
                    println!("\nNote: Retransmit tracking is only available on Linux systems.");
                }
                ProgressEvent::Error(msg) => {
                    eprintln!("Error: {}", msg);
                }
            });

            client.run().await?;
        }
        _ => {
            eprintln!("Usage: {} [server|client]", args[0]);
            std::process::exit(1);
        }
    }

    Ok(())
}

pub fn client(server_addr: String, port: u16) -> Self

Creates a new client configuration.

Sets up the configuration for client mode, which connects to a server at the specified address and port.

Arguments

• server_addr - The IP address or hostname of the server
• port - The port number to connect to (typically 5201)

Examples

use rperf3::Config;

let config = Config::client("192.168.1.100".to_string(), 5201);

Examples found in repository

examples/test_json_output.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_duration(Duration::from_secs(3))
        .with_json(true);

    let client = Client::new(config)?;

    match client.run().await {
        Ok(_) => println!("\nTest completed successfully"),
        Err(e) => eprintln!("\nError: {}", e),
    }

    Ok(())
}

examples/client.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Connecting to rperf3 server at 127.0.0.1:5201...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/udp_client.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Running UDP test with 50 Mbps target bandwidth...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(10))
        .with_bandwidth(50 * 1_000_000) // 50 Mbps
        .with_buffer_size(1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/client_with_callback.rs (line 56)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("rperf3 Client with Callback Example");
    println!("====================================\n");

    // Configure the test
    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024)
        .with_interval(Duration::from_secs(2)); // Report every 2 seconds

    // Create client with custom callback
    let client = Client::new(config)?.with_callback(MyProgressCallback);

    println!("Connecting to server at 127.0.0.1:5201...\n");

    // Run the test (callback will be invoked during execution)
    client.run().await?;

    // Get final measurements
    let measurements = client.get_measurements();
    println!("\n📈 Final Statistics:");
    println!("   Total bytes: {}", measurements.total_bytes_sent);
    println!(
        "   Duration: {:.2}s",
        measurements.total_duration.as_secs_f64()
    );
    println!(
        "   Average bandwidth: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/tcp_nodelay_test.rs (line 45)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("TCP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests TCP with:");
    println!("- TCP_NODELAY enabled (Nagle's algorithm disabled)");
    println!("- 256KB send/receive buffers");
    println!("- Expected 10-20% improvement over default settings\n");

    // Start server in background
    let server_config = Config::server(5201).with_protocol(Protocol::Tcp);
    let server = Server::new(server_config);

    // Run server in background task
    tokio::spawn(async move {
        if let Err(e) = server.run().await {
            eprintln!("Server error: {}", e);
        }
    });

    // Give server time to start
    time::sleep(Duration::from_millis(100)).await;

    println!("Starting TCP test (5 seconds)...\n");

    // Run client test
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1));

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("\nSocket optimizations applied:");
    println!("✓ TCP_NODELAY: enabled");
    println!("✓ Send buffer: 256KB");
    println!("✓ Recv buffer: 256KB");

    Ok(())
}

examples/udp_buffer_test.rs (line 36)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("UDP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests UDP with:");
    println!("- 2MB send/receive buffers");
    println!("- Improved burst handling");
    println!("- Expected 10-20% improvement with reduced packet loss\n");
    println!("Note: Make sure the server is running first:");
    println!("  cargo run --release -- -s -p 5201\n");

    println!("Starting UDP test (5 seconds, 100 Mbps)...\n");

    // Run client test with bandwidth limiting
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1))
        .with_bandwidth(100_000_000); // 100 Mbps

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();
    let packet_loss = if measurements.total_packets > 0 {
        (measurements.lost_packets as f64 / measurements.total_packets as f64) * 100.0
    } else {
        0.0
    };

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("Packet loss: {:.2}%", packet_loss);
    println!("\nSocket optimizations applied:");
    println!("✓ Send buffer: 2MB");
    println!("✓ Recv buffer: 2MB");
    println!("✓ Reduced packet loss with larger buffers");

    Ok(())
}

Additional examples can be found in:

• examples/cancellable_test.rs
• examples/test_retransmits.rs
• examples/client_closure_callback.rs

pub fn with_protocol(self, protocol: Protocol) -> Self

Sets the protocol to use for the test.

Arguments

• protocol - Either Protocol::Tcp or Protocol::Udp

Examples

use rperf3::{Config, Protocol};

let config = Config::client("127.0.0.1".to_string(), 5201)
    .with_protocol(Protocol::Udp);

Examples found in repository

examples/server.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Starting rperf3 server on port 5201...");

    let config = Config::server(5201).with_protocol(Protocol::Tcp);

    let server = Server::new(config);
    server.run().await?;

    Ok(())
}

examples/client.rs (line 11)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Connecting to rperf3 server at 127.0.0.1:5201...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/udp_client.rs (line 11)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Running UDP test with 50 Mbps target bandwidth...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(10))
        .with_bandwidth(50 * 1_000_000) // 50 Mbps
        .with_buffer_size(1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/client_with_callback.rs (line 57)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("rperf3 Client with Callback Example");
    println!("====================================\n");

    // Configure the test
    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024)
        .with_interval(Duration::from_secs(2)); // Report every 2 seconds

    // Create client with custom callback
    let client = Client::new(config)?.with_callback(MyProgressCallback);

    println!("Connecting to server at 127.0.0.1:5201...\n");

    // Run the test (callback will be invoked during execution)
    client.run().await?;

    // Get final measurements
    let measurements = client.get_measurements();
    println!("\n📈 Final Statistics:");
    println!("   Total bytes: {}", measurements.total_bytes_sent);
    println!(
        "   Duration: {:.2}s",
        measurements.total_duration.as_secs_f64()
    );
    println!(
        "   Average bandwidth: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/tcp_nodelay_test.rs (line 29)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("TCP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests TCP with:");
    println!("- TCP_NODELAY enabled (Nagle's algorithm disabled)");
    println!("- 256KB send/receive buffers");
    println!("- Expected 10-20% improvement over default settings\n");

    // Start server in background
    let server_config = Config::server(5201).with_protocol(Protocol::Tcp);
    let server = Server::new(server_config);

    // Run server in background task
    tokio::spawn(async move {
        if let Err(e) = server.run().await {
            eprintln!("Server error: {}", e);
        }
    });

    // Give server time to start
    time::sleep(Duration::from_millis(100)).await;

    println!("Starting TCP test (5 seconds)...\n");

    // Run client test
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1));

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("\nSocket optimizations applied:");
    println!("✓ TCP_NODELAY: enabled");
    println!("✓ Send buffer: 256KB");
    println!("✓ Recv buffer: 256KB");

    Ok(())
}

examples/udp_buffer_test.rs (line 37)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("UDP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests UDP with:");
    println!("- 2MB send/receive buffers");
    println!("- Improved burst handling");
    println!("- Expected 10-20% improvement with reduced packet loss\n");
    println!("Note: Make sure the server is running first:");
    println!("  cargo run --release -- -s -p 5201\n");

    println!("Starting UDP test (5 seconds, 100 Mbps)...\n");

    // Run client test with bandwidth limiting
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1))
        .with_bandwidth(100_000_000); // 100 Mbps

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();
    let packet_loss = if measurements.total_packets > 0 {
        (measurements.lost_packets as f64 / measurements.total_packets as f64) * 100.0
    } else {
        0.0
    };

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("Packet loss: {:.2}%", packet_loss);
    println!("\nSocket optimizations applied:");
    println!("✓ Send buffer: 2MB");
    println!("✓ Recv buffer: 2MB");
    println!("✓ Reduced packet loss with larger buffers");

    Ok(())
}

Additional examples can be found in:

• examples/client_closure_callback.rs

pub fn with_duration(self, duration: Duration) -> Self

Sets the test duration.

Arguments

• duration - How long the test should run

Examples

use rperf3::Config;
use std::time::Duration;

let config = Config::client("127.0.0.1".to_string(), 5201)
    .with_duration(Duration::from_secs(30));

Examples found in repository

examples/test_json_output.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_duration(Duration::from_secs(3))
        .with_json(true);

    let client = Client::new(config)?;

    match client.run().await {
        Ok(_) => println!("\nTest completed successfully"),
        Err(e) => eprintln!("\nError: {}", e),
    }

    Ok(())
}

examples/client.rs (line 12)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Connecting to rperf3 server at 127.0.0.1:5201...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/udp_client.rs (line 12)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Running UDP test with 50 Mbps target bandwidth...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(10))
        .with_bandwidth(50 * 1_000_000) // 50 Mbps
        .with_buffer_size(1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/client_with_callback.rs (line 58)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("rperf3 Client with Callback Example");
    println!("====================================\n");

    // Configure the test
    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024)
        .with_interval(Duration::from_secs(2)); // Report every 2 seconds

    // Create client with custom callback
    let client = Client::new(config)?.with_callback(MyProgressCallback);

    println!("Connecting to server at 127.0.0.1:5201...\n");

    // Run the test (callback will be invoked during execution)
    client.run().await?;

    // Get final measurements
    let measurements = client.get_measurements();
    println!("\n📈 Final Statistics:");
    println!("   Total bytes: {}", measurements.total_bytes_sent);
    println!(
        "   Duration: {:.2}s",
        measurements.total_duration.as_secs_f64()
    );
    println!(
        "   Average bandwidth: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/tcp_nodelay_test.rs (line 47)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("TCP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests TCP with:");
    println!("- TCP_NODELAY enabled (Nagle's algorithm disabled)");
    println!("- 256KB send/receive buffers");
    println!("- Expected 10-20% improvement over default settings\n");

    // Start server in background
    let server_config = Config::server(5201).with_protocol(Protocol::Tcp);
    let server = Server::new(server_config);

    // Run server in background task
    tokio::spawn(async move {
        if let Err(e) = server.run().await {
            eprintln!("Server error: {}", e);
        }
    });

    // Give server time to start
    time::sleep(Duration::from_millis(100)).await;

    println!("Starting TCP test (5 seconds)...\n");

    // Run client test
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1));

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("\nSocket optimizations applied:");
    println!("✓ TCP_NODELAY: enabled");
    println!("✓ Send buffer: 256KB");
    println!("✓ Recv buffer: 256KB");

    Ok(())
}

examples/udp_buffer_test.rs (line 38)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("UDP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests UDP with:");
    println!("- 2MB send/receive buffers");
    println!("- Improved burst handling");
    println!("- Expected 10-20% improvement with reduced packet loss\n");
    println!("Note: Make sure the server is running first:");
    println!("  cargo run --release -- -s -p 5201\n");

    println!("Starting UDP test (5 seconds, 100 Mbps)...\n");

    // Run client test with bandwidth limiting
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1))
        .with_bandwidth(100_000_000); // 100 Mbps

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();
    let packet_loss = if measurements.total_packets > 0 {
        (measurements.lost_packets as f64 / measurements.total_packets as f64) * 100.0
    } else {
        0.0
    };

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("Packet loss: {:.2}%", packet_loss);
    println!("\nSocket optimizations applied:");
    println!("✓ Send buffer: 2MB");
    println!("✓ Recv buffer: 2MB");
    println!("✓ Reduced packet loss with larger buffers");

    Ok(())
}

Additional examples can be found in:

• examples/cancellable_test.rs
• examples/test_retransmits.rs
• examples/client_closure_callback.rs

pub fn with_bandwidth(self, bandwidth: u64) -> Self

Sets the target bandwidth for tests.

Controls the send rate for both TCP and UDP tests. The bandwidth limiter uses a rate-based algorithm that checks bandwidth every 1ms and sleeps when sending too fast.

Arguments

• bandwidth - Target bandwidth in bits per second

Examples

use rperf3::{Config, Protocol};

// UDP test at 100 Mbps
let udp_config = Config::client("127.0.0.1".to_string(), 5201)
    .with_protocol(Protocol::Udp)
    .with_bandwidth(100_000_000); // 100 Mbps

// TCP test at 50 Mbps
let tcp_config = Config::client("127.0.0.1".to_string(), 5201)
    .with_protocol(Protocol::Tcp)
    .with_bandwidth(50_000_000); // 50 Mbps

Examples found in repository

examples/udp_client.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Running UDP test with 50 Mbps target bandwidth...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(10))
        .with_bandwidth(50 * 1_000_000) // 50 Mbps
        .with_buffer_size(1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/udp_buffer_test.rs (line 40)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("UDP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests UDP with:");
    println!("- 2MB send/receive buffers");
    println!("- Improved burst handling");
    println!("- Expected 10-20% improvement with reduced packet loss\n");
    println!("Note: Make sure the server is running first:");
    println!("  cargo run --release -- -s -p 5201\n");

    println!("Starting UDP test (5 seconds, 100 Mbps)...\n");

    // Run client test with bandwidth limiting
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1))
        .with_bandwidth(100_000_000); // 100 Mbps

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();
    let packet_loss = if measurements.total_packets > 0 {
        (measurements.lost_packets as f64 / measurements.total_packets as f64) * 100.0
    } else {
        0.0
    };

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("Packet loss: {:.2}%", packet_loss);
    println!("\nSocket optimizations applied:");
    println!("✓ Send buffer: 2MB");
    println!("✓ Recv buffer: 2MB");
    println!("✓ Reduced packet loss with larger buffers");

    Ok(())
}

pub fn with_buffer_size(self, size: usize) -> Self

Sets the buffer size for data transfer.

Larger buffer sizes can improve throughput but use more memory.

Arguments

• size - Buffer size in bytes (default: 128 KB)

Examples

use rperf3::Config;

let config = Config::client("127.0.0.1".to_string(), 5201)
    .with_buffer_size(256 * 1024); // 256 KB

Examples found in repository

examples/client.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Connecting to rperf3 server at 127.0.0.1:5201...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/udp_client.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("Running UDP test with 50 Mbps target bandwidth...");

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(10))
        .with_bandwidth(50 * 1_000_000) // 50 Mbps
        .with_buffer_size(1024);

    let client = Client::new(config)?;
    client.run().await?;

    let measurements = client.get_measurements();
    println!(
        "\nFinal Results: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/client_with_callback.rs (line 59)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("rperf3 Client with Callback Example");
    println!("====================================\n");

    // Configure the test
    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024)
        .with_interval(Duration::from_secs(2)); // Report every 2 seconds

    // Create client with custom callback
    let client = Client::new(config)?.with_callback(MyProgressCallback);

    println!("Connecting to server at 127.0.0.1:5201...\n");

    // Run the test (callback will be invoked during execution)
    client.run().await?;

    // Get final measurements
    let measurements = client.get_measurements();
    println!("\n📈 Final Statistics:");
    println!("   Total bytes: {}", measurements.total_bytes_sent);
    println!(
        "   Duration: {:.2}s",
        measurements.total_duration.as_secs_f64()
    );
    println!(
        "   Average bandwidth: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/client_closure_callback.rs (line 20)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("rperf3 Client with Closure Callback Example");
    println!("===========================================\n");

    // Track progress with shared state
    let progress = Arc::new(Mutex::new(Vec::new()));
    let progress_clone = Arc::clone(&progress);

    // Configure the test
    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(5))
        .with_buffer_size(128 * 1024)
        .with_interval(Duration::from_secs(1));

    // Create client with closure callback
    let client = Client::new(config)?.with_callback(move |event: ProgressEvent| {
        match &event {
            ProgressEvent::TestStarted => {
                println!("✨ Starting test...");
            }
            ProgressEvent::IntervalUpdate {
                interval_end,
                bytes,
                bits_per_second,
                ..
            } => {
                let mbps = bits_per_second / 1_000_000.0;
                println!(
                    "⏱️  {:>5.1}s | {:>10} bytes | {:>8.2} Mbps",
                    interval_end.as_secs_f64(),
                    bytes,
                    mbps
                );

                // Store progress for later analysis
                if let Ok(mut prog) = progress_clone.lock() {
                    prog.push((*interval_end, *bytes, *bits_per_second));
                }
            }
            ProgressEvent::TestCompleted {
                total_bytes,
                duration,
                bits_per_second,
                ..
            } => {
                println!("\n🎉 Test finished!");
                println!("   {} bytes in {:.2}s", total_bytes, duration.as_secs_f64());
                println!("   Average: {:.2} Mbps", bits_per_second / 1_000_000.0);
            }
            ProgressEvent::Error(msg) => {
                eprintln!("❌ Error: {}", msg);
            }
        }
    });

    println!("Connecting to server at 127.0.0.1:5201...\n");

    // Run the test
    client.run().await?;

    // Analyze collected progress data
    if let Ok(prog) = progress.lock() {
        if !prog.is_empty() {
            println!("\n📊 Progress Analysis:");
            let avg_mbps: f64 = prog
                .iter()
                .map(|(_, _, bps)| bps / 1_000_000.0)
                .sum::<f64>()
                / prog.len() as f64;
            println!("   Intervals recorded: {}", prog.len());
            println!("   Average interval speed: {:.2} Mbps", avg_mbps);

            let max_mbps = prog
                .iter()
                .map(|(_, _, bps)| bps / 1_000_000.0)
                .fold(0.0f64, f64::max);
            let min_mbps = prog
                .iter()
                .map(|(_, _, bps)| bps / 1_000_000.0)
                .fold(f64::INFINITY, f64::min);
            println!("   Peak speed: {:.2} Mbps", max_mbps);
            println!("   Lowest speed: {:.2} Mbps", min_mbps);
        }
    }

    Ok(())
}

pub fn with_parallel(self, parallel: usize) -> Self

Sets the number of parallel streams.

Multiple parallel streams can improve throughput by utilizing multiple connections simultaneously. This is particularly useful for high-bandwidth networks where a single stream might not saturate the link.

Arguments

• parallel - Number of parallel streams (default: 1)

Examples

use rperf3::Config;

let config = Config::client("127.0.0.1".to_string(), 5201)
    .with_parallel(4); // Use 4 parallel streams

pub fn with_reverse(self, reverse: bool) -> Self

Enables or disables reverse mode.

In reverse mode, the server sends data and the client receives. In normal mode, the client sends data and the server receives.

Arguments

• reverse - true for reverse mode, false for normal mode

Examples

use rperf3::Config;

let config = Config::client("127.0.0.1".to_string(), 5201)
    .with_reverse(true);

pub fn with_json(self, json: bool) -> Self

Enables or disables JSON output format.

When enabled, results are output in machine-readable JSON format similar to iperf3.

Arguments

• json - true to enable JSON output, false for human-readable

Examples

use rperf3::Config;

let config = Config::client("127.0.0.1".to_string(), 5201)
    .with_json(true);

Examples found in repository

examples/test_json_output.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_duration(Duration::from_secs(3))
        .with_json(true);

    let client = Client::new(config)?;

    match client.run().await {
        Ok(_) => println!("\nTest completed successfully"),
        Err(e) => eprintln!("\nError: {}", e),
    }

    Ok(())
}

pub fn with_interval(self, interval: Duration) -> Self

Sets the interval for periodic reporting.

Statistics will be reported at this interval during the test.

Arguments

• interval - How often to report statistics (default: 1 second)

Examples

use rperf3::Config;
use std::time::Duration;

let config = Config::client("127.0.0.1".to_string(), 5201)
    .with_interval(Duration::from_secs(2));

Examples found in repository

examples/client_with_callback.rs (line 60)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("rperf3 Client with Callback Example");
    println!("====================================\n");

    // Configure the test
    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(10))
        .with_buffer_size(128 * 1024)
        .with_interval(Duration::from_secs(2)); // Report every 2 seconds

    // Create client with custom callback
    let client = Client::new(config)?.with_callback(MyProgressCallback);

    println!("Connecting to server at 127.0.0.1:5201...\n");

    // Run the test (callback will be invoked during execution)
    client.run().await?;

    // Get final measurements
    let measurements = client.get_measurements();
    println!("\n📈 Final Statistics:");
    println!("   Total bytes: {}", measurements.total_bytes_sent);
    println!(
        "   Duration: {:.2}s",
        measurements.total_duration.as_secs_f64()
    );
    println!(
        "   Average bandwidth: {:.2} Mbps",
        measurements.total_bits_per_second() / 1_000_000.0
    );

    Ok(())
}

examples/tcp_nodelay_test.rs (line 48)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("TCP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests TCP with:");
    println!("- TCP_NODELAY enabled (Nagle's algorithm disabled)");
    println!("- 256KB send/receive buffers");
    println!("- Expected 10-20% improvement over default settings\n");

    // Start server in background
    let server_config = Config::server(5201).with_protocol(Protocol::Tcp);
    let server = Server::new(server_config);

    // Run server in background task
    tokio::spawn(async move {
        if let Err(e) = server.run().await {
            eprintln!("Server error: {}", e);
        }
    });

    // Give server time to start
    time::sleep(Duration::from_millis(100)).await;

    println!("Starting TCP test (5 seconds)...\n");

    // Run client test
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1));

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("\nSocket optimizations applied:");
    println!("✓ TCP_NODELAY: enabled");
    println!("✓ Send buffer: 256KB");
    println!("✓ Recv buffer: 256KB");

    Ok(())
}

examples/udp_buffer_test.rs (line 39)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    println!("UDP Socket Optimization Demo");
    println!("============================\n");
    println!("This demo tests UDP with:");
    println!("- 2MB send/receive buffers");
    println!("- Improved burst handling");
    println!("- Expected 10-20% improvement with reduced packet loss\n");
    println!("Note: Make sure the server is running first:");
    println!("  cargo run --release -- -s -p 5201\n");

    println!("Starting UDP test (5 seconds, 100 Mbps)...\n");

    // Run client test with bandwidth limiting
    let client_config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Udp)
        .with_duration(Duration::from_secs(5))
        .with_interval(Duration::from_secs(1))
        .with_bandwidth(100_000_000); // 100 Mbps

    let client = Client::new(client_config)?;
    client.run().await?;

    // Get measurements
    let measurements = client.get_measurements();
    let total_bytes = measurements.total_bytes_sent + measurements.total_bytes_received;
    let bits_per_second = measurements.total_bits_per_second();
    let packet_loss = if measurements.total_packets > 0 {
        (measurements.lost_packets as f64 / measurements.total_packets as f64) * 100.0
    } else {
        0.0
    };

    println!("\n=== Results ===");
    println!(
        "Total transferred: {:.2} MB",
        total_bytes as f64 / 1_000_000.0
    );
    println!("Throughput: {:.2} Mbps", bits_per_second / 1_000_000.0);
    println!("Packet loss: {:.2}%", packet_loss);
    println!("\nSocket optimizations applied:");
    println!("✓ Send buffer: 2MB");
    println!("✓ Recv buffer: 2MB");
    println!("✓ Reduced packet loss with larger buffers");

    Ok(())
}

examples/client_closure_callback.rs (line 21)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("rperf3 Client with Closure Callback Example");
    println!("===========================================\n");

    // Track progress with shared state
    let progress = Arc::new(Mutex::new(Vec::new()));
    let progress_clone = Arc::clone(&progress);

    // Configure the test
    let config = Config::client("127.0.0.1".to_string(), 5201)
        .with_protocol(Protocol::Tcp)
        .with_duration(Duration::from_secs(5))
        .with_buffer_size(128 * 1024)
        .with_interval(Duration::from_secs(1));

    // Create client with closure callback
    let client = Client::new(config)?.with_callback(move |event: ProgressEvent| {
        match &event {
            ProgressEvent::TestStarted => {
                println!("✨ Starting test...");
            }
            ProgressEvent::IntervalUpdate {
                interval_end,
                bytes,
                bits_per_second,
                ..
            } => {
                let mbps = bits_per_second / 1_000_000.0;
                println!(
                    "⏱️  {:>5.1}s | {:>10} bytes | {:>8.2} Mbps",
                    interval_end.as_secs_f64(),
                    bytes,
                    mbps
                );

                // Store progress for later analysis
                if let Ok(mut prog) = progress_clone.lock() {
                    prog.push((*interval_end, *bytes, *bits_per_second));
                }
            }
            ProgressEvent::TestCompleted {
                total_bytes,
                duration,
                bits_per_second,
                ..
            } => {
                println!("\n🎉 Test finished!");
                println!("   {} bytes in {:.2}s", total_bytes, duration.as_secs_f64());
                println!("   Average: {:.2} Mbps", bits_per_second / 1_000_000.0);
            }
            ProgressEvent::Error(msg) => {
                eprintln!("❌ Error: {}", msg);
            }
        }
    });

    println!("Connecting to server at 127.0.0.1:5201...\n");

    // Run the test
    client.run().await?;

    // Analyze collected progress data
    if let Ok(prog) = progress.lock() {
        if !prog.is_empty() {
            println!("\n📊 Progress Analysis:");
            let avg_mbps: f64 = prog
                .iter()
                .map(|(_, _, bps)| bps / 1_000_000.0)
                .sum::<f64>()
                / prog.len() as f64;
            println!("   Intervals recorded: {}", prog.len());
            println!("   Average interval speed: {:.2} Mbps", avg_mbps);

            let max_mbps = prog
                .iter()
                .map(|(_, _, bps)| bps / 1_000_000.0)
                .fold(0.0f64, f64::max);
            let min_mbps = prog
                .iter()
                .map(|(_, _, bps)| bps / 1_000_000.0)
                .fold(f64::INFINITY, f64::min);
            println!("   Peak speed: {:.2} Mbps", max_mbps);
            println!("   Lowest speed: {:.2} Mbps", min_mbps);
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Config

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.