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