mio

Mio is a low-level I/O library for Rust focusing on non-blocking APIs and event notification. To use Mio, follow these three steps:

1. Create a Poll instance: This monitors events from the OS and puts them into Events.
2. Register an event source: Provide a source (like a TcpListener) to the Poll instance using a Token to identify it later.
3. Create an event loop: Call poll.poll() in a loop to retrieve events and process them based on their associated Token.

use std::io;
use std::time::Duration;
use mio::net::TcpListener;
use mio::{Poll, Token, Interest, Events};

fn main() -> io::Result<()> {
    let mut poll = Poll::new()?;
    let mut events = Events::with_capacity(128);
    let address = "127.0.0.1:0".parse().unwrap();
    let mut listener = TcpListener::bind(address)?;
    
    const SERVER: Token = Token(0);
    poll.registry().register(&mut listener, SERVER, Interest::READABLE)?;

    loop {
        poll.poll(&mut events, Some(Duration::from_millis(100)))?;

        for event in events.iter() {
            match event.token() {
                SERVER => loop {
                    match listener.accept() {
                        Ok((connection, address)) => {
                            println!("Got a connection from: {}", address);
                            drop(connection);
                        },
                        Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => break,
                        Err(err) => return Err(err),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
}

Mio uses a Poll instance to monitor multiple I/O sources for events. You register sockets (like TcpListener or TcpStream) with a Registry using a unique Token to identify them when events occur. The event loop typically calls poll.poll() to block until events are ready, then iterates through the Events to process them based on the provided Token and event type (e.g., is_readable(), is_writable()).

use std::error::Error;

use mio::net::{TcpListener, TcpStream};
use mio::{Events, Interest, Poll, Token};

// Some tokens to allow us to identify which event is for which socket.
const SERVER: Token = Token(0);
const CLIENT: Token = Token(1);

fn main() -> Result<(), Box<dyn Error>> {
    // Create a poll instance.
    let mut poll = Poll::new()?;
    // Create storage for events.
    let mut events = Events::with_capacity(128);

    // Setup the server socket.
    let addr = "127.0.0.1:13265".parse()?;
    let mut server = TcpListener::bind(addr)?;
    // Start listening for incoming connections.
    poll.registry()
        .register(&mut server, SERVER, Interest::READABLE)?;

    // Setup the client socket.
    let mut client = TcpStream::connect(addr)?;
    // Register the socket.
    poll.registry()
        .register(&mut client, CLIENT, Interest::READABLE | Interest::WRITABLE)?;

    // Start an event loop.
    loop {
        // Poll Mio for events, blocking until we get an event.
        poll.poll(&mut events, None)?;

        // Process each event.
        for event in events.iter() {
            // We can use the token we previously provided to `register` to
            // determine for which socket the event is.
            match event.token() {
                SERVER => {
                    // If this is an event for the server, it means a connection is ready to be accepted.
                    // Accept the connection and drop it immediately. This will
                    // close the socket and notify the client of the EOF.
                    let connection = server.accept();
                    drop(connection);
                }
                CLIENT => {
                    if event.is_writable() {
                        // We can (likely) write to the socket without blocking.
                    }

                    if event.is_readable() {
                        // We can (likely) read from the socket without blocking.
                    }

                    // Since the server just shuts down the connection, let's
                    // just exit from our event loop.
                    return Ok(());
                }
                // We don't expect any events with tokens other than those we provided.
                _ => unreachable!(),
            }
        }
    }
}