zonai 0.0.2

Synchronous packet-framed TCP clients and servers
Documentation
use std::{
    env,
    io::{self, Read, Write},
    net::SocketAddr,
    thread,
    time::Duration,
};

use zonai::{
    packet::{PacketIn, PacketOut},
    server::{Server, ServerEvent},
};

const MAX_MESSAGE_LEN: usize = 60 * 1024;

#[derive(Debug)]
struct Message(String);

impl PacketIn for Message {
    fn read(reader: &mut impl Read) -> io::Result<Self> {
        let mut length = [0; 4];
        reader.read_exact(&mut length)?;
        let length = u32::from_be_bytes(length) as usize;
        if length > MAX_MESSAGE_LEN {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                "message exceeds the protocol limit",
            ));
        }

        let mut bytes = vec![0; length];
        reader.read_exact(&mut bytes)?;
        let message = String::from_utf8(bytes)
            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
        Ok(Self(message))
    }
}

impl PacketOut for Message {
    fn write(&self, writer: &mut impl Write) -> io::Result<()> {
        let bytes = self.0.as_bytes();
        if bytes.len() > MAX_MESSAGE_LEN {
            return Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "message exceeds the protocol limit",
            ));
        }

        writer.write_all(&(bytes.len() as u32).to_be_bytes())?;
        writer.write_all(bytes)
    }
}

fn main() -> io::Result<()> {
    let addr = env::args()
        .nth(1)
        .unwrap_or_else(|| "127.0.0.1:4000".to_owned())
        .parse::<SocketAddr>()
        .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
    let server = Server::<Message, Message>::bind(addr)?;
    println!("listening on {}", server.local_addr());

    'server: loop {
        match server.poll()? {
            Some(ServerEvent::Accept { client, peer_addr }) => {
                println!("client {client} connected from {peer_addr}");
                server.send(client, Message("welcome".to_owned()))?;
            }
            Some(ServerEvent::Packet { client, packet }) => {
                println!("client {client}: {}", packet.0);
                match packet.0.as_str() {
                    "quit" => server.disconnect(client)?,
                    "shutdown" => break 'server,
                    _ => server.send(client, Message(format!("echo: {}", packet.0)))?,
                }
            }
            Some(ServerEvent::Lost { client, error }) => match error {
                Some(error) => eprintln!("client {client} disconnected: {error}"),
                None => println!("client {client} disconnected"),
            },
            None => thread::sleep(Duration::from_millis(1)),
        }
    }

    server.shutdown_and_wait()
}