Network Programming with Rust

The server operates using the following logic:

1. Binding: It binds to 127.0.0.1:8888 using std::net::TcpListener.
2. Concurrency: It uses listener.incoming() to accept connections. Each successful connection is moved into a new thread via thread::spawn to allow multiple clients to be handled simultaneously.
3. Client Handling: The handle_client function reads data from the TcpStream into a 512-byte buffer.
4. Random Delay: Before writing the data back, the server calculates a random Duration using rand::thread_rng().choose(&[0, 1, 2, 3, 4, 5]) and sleeps for that amount of time.
5. Echo: The exact bytes read are written back to the stream using stream.write().

// Core logic snippet from handle_client
let sleep = Duration::from_secs(*thread_rng().choose(&[0, 1, 2, 3, 4, 5]).unwrap());
std::thread::sleep(sleep);
stream.write(&buf[..bytes_read])?;

To create a non-blocking TCP server using mio, follow these steps:

1. Bind the Listener: Use mio::tcp::TcpListener::bind to bind to a SocketAddr.
2. Initialize Poll: Create a new event loop instance using Poll::new().
3. Register the Listener: Register the TcpListener with the Poll instance. Use a unique Token to identify the listener in the event loop and specify the interest (e.g., Ready::readable()). Using PollOpt::edge() enables edge-triggered notifications.
4. Event Loop: Create an Events collection and enter a loop calling poll.poll(&mut events, None).
5. Handle Events: Iterate through the returned events and match on the Token. For a server listener token, call server.accept() to handle new connections.

use mio::*;
use mio::tcp::TcpListener;

const SERVER: Token = Token(0);

// ... inside run() method ...
let server = TcpListener::bind(&address).unwrap();
let poll = Poll::new().unwrap();
poll.register(&server, SERVER, Ready::readable(), PollOpt::edge()).unwrap();

let mut events = Events::with_capacity(1024);
loop {
    poll.poll(&mut events, None).unwrap();
    for event in events.iter() {
        match event.token() {
            SERVER => {
                let (_stream, remote) = server.accept().unwrap();
                println!("Connection from {}", remote);
            }
            _ => {}
        }
    }
}

To maximize throughput, you can scale a hyper server by spawning multiple worker threads, each running its own event loop (tokio_core::reactor::Core).

1. Use net2::TcpBuilder with .reuse_port(true) to allow multiple processes/threads to bind to the same address.
2. Use start_server to spawn num_cpus::get() - 1 threads, each running the serve function.
3. The main thread then runs the final instance of serve.

This pattern utilizes Arc<Http> to share the protocol configuration across all worker threads.

fn start_server(num: usize, addr: &str) {
    let addr = addr.parse().unwrap();
    let protocol = Arc::new(Http::new());
    {
        for _ in 0..num - 1 {
            let protocol = Arc::clone(&protocol);
            thread::spawn(move || serve(&addr, &protocol));
        }
    }
    serve(&addr, &protocol);
}

fn main() {
    // Scales to the number of available CPUs
    start_server(num_cpus::get(), "0.0.0.0:3000");
}

You can configure the may runtime and start an HttpServer by following these steps:

1. Configure IO Workers: Use may::config().set_io_workers(n) to set the number of IO workers (typically matching the number of CPU cores).
2. Initialize Server: Instantiate HttpServer with your HttpService implementation and call .start("address:port").
3. Run: Call .join() on the server instance to block the main thread and keep the server running.

Note: .start() and .join() return Result types and should be handled with .unwrap() or proper error handling.

fn main() {
    // Set IO workers to the number of available CPUs
    may::config().set_io_workers(num_cpus::get());

    // Start the server on 0.0.0.0:3000 with the Echo service
    let server = HttpServer(Echo).start("0.0.0.0:3000").unwrap();

    // Wait for the server to finish
    server.join().unwrap();
}