Struct Server 

pub struct Server { /* private fields */ }

Network performance test server.

The Server listens for incoming TCP control connections and handles both TCP and UDP performance test requests. All tests use a TCP control channel for coordination, with UDP data transfer happening on the same port. The server supports reverse mode testing, bandwidth limiting, interval reporting, JSON output, and can handle multiple concurrent clients.

Features

• TCP Control Channel: Always uses TCP for client coordination
• TCP and UDP Data: Handle both reliable (TCP) and unreliable (UDP) performance tests
• Reverse Mode: Send data to client for reverse throughput testing
• Bandwidth Limiting: Control send rate in reverse mode tests
• Interval Reporting: Display periodic statistics during tests
• JSON Output: Machine-readable output format for automation
• UDP Metrics: Track packet loss, jitter, and out-of-order delivery
• Concurrent Clients: Handle multiple simultaneous test connections

Examples

Basic TCP Server

use rperf3::{Server, Config};

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

println!("Starting server on port 5201...");
server.run().await?;

UDP Server with Reverse Mode

use rperf3::{Server, Config, Protocol};

let config = Config::server(5201)
    .with_protocol(Protocol::Udp)
    .with_reverse(true); // Server will send UDP data

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

Implementations

impl Server

pub fn new(config: Config) -> Self

Creates a new server with the given configuration.

Arguments

• config - The server configuration including port and protocol

Examples

use rperf3::{Server, Config};

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

Examples found in repository

examples/server.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!("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 35)

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 30)

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 24)

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 cancellation_token(&self) -> &CancellationToken

Returns a reference to the cancellation token.

This allows external code to cancel the running server gracefully.

Examples

use rperf3::{Server, Config};

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

// Get cancellation token to stop from another task
let cancel_token = server.cancellation_token().clone();

tokio::spawn(async move {
    // Server will be running
});

// Later, to stop the server:
cancel_token.cancel();

Examples found in repository

examples/cancellable_test.rs (line 38)

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(())
}

pub async fn run(&self) -> Result<()>

Starts the server and begins listening for client connections.

This method will run indefinitely, accepting and handling client connections. For TCP, each client connection is handled in a separate task. For UDP, the server processes incoming datagrams.

Errors

Returns an error if:

• Cannot bind to the specified port
• Network I/O errors occur

Examples

use rperf3::{Server, Config};

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

println!("Server running...");
server.run().await?;

Examples found in repository

examples/server.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!("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 49)

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 34)

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 25)

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 get_measurements(&self) -> Measurements

Retrieves the current measurements collected by the server.

Returns a snapshot of the statistics collected from client tests. This includes total bytes transferred, bandwidth measurements, and UDP-specific metrics like packet loss and jitter.

Returns

A Measurements struct containing comprehensive test statistics.

Examples

use rperf3::{Server, Config};

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

// After tests have run
let measurements = server.get_measurements();
println!("Total bytes: {}", measurements.total_bytes_received);
println!("Throughput: {:.2} Mbps",
         measurements.total_bits_per_second() / 1_000_000.0);