#![allow(clippy::expect_used)]
use std::{
io::{self, Read, Write},
net::{Shutdown, TcpListener as StdTcpListener, TcpStream as StdTcpStream},
sync::{
Arc,
atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering},
mpsc,
},
thread,
time::{Duration, Instant},
};
use zonai::{
packet::{PacketIn, PacketOut},
server::{Server, ServerClient, ServerConfig, ServerEvent},
};
#[derive(Clone, Debug, PartialEq, Eq)]
struct BytesPacket(Vec<u8>);
impl PacketIn for BytesPacket {
fn read(read: &mut impl Read) -> io::Result<Self> {
let mut len = [0; 4];
read.read_exact(&mut len)?;
let mut buf = vec![0; u32::from_be_bytes(len) as usize];
read.read_exact(&mut buf)?;
Ok(Self(buf))
}
}
impl PacketOut for BytesPacket {
fn write(&self, write: &mut impl Write) -> io::Result<()> {
write.write_all(&(self.0.len() as u32).to_be_bytes())?;
write.write_all(&self.0)
}
}
#[derive(Debug)]
struct InvalidPacket;
impl PacketIn for InvalidPacket {
fn read(read: &mut impl Read) -> io::Result<Self> {
let mut byte = [0];
read.read_exact(&mut byte)?;
Err(io::Error::new(io::ErrorKind::InvalidData, "invalid"))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct OneBytePacket(u8);
impl PacketIn for OneBytePacket {
fn read(read: &mut impl Read) -> io::Result<Self> {
let mut byte = [0];
read.read_exact(&mut byte)?;
Ok(Self(byte[0]))
}
}
#[derive(Debug)]
struct EmptyPacket;
impl PacketOut for EmptyPacket {
fn write(&self, _write: &mut impl Write) -> io::Result<()> {
Ok(())
}
}
impl PacketOut for OneBytePacket {
fn write(&self, write: &mut impl Write) -> io::Result<()> {
write.write_all(&[self.0])
}
}
struct CountingPacket {
encodes: Arc<AtomicUsize>,
payload_len: usize,
}
impl PacketOut for CountingPacket {
fn write(&self, write: &mut impl Write) -> io::Result<()> {
self.encodes.fetch_add(1, AtomicOrdering::Relaxed);
write.write_all(&vec![1; self.payload_len])
}
}
fn test_net(config: ServerConfig) -> Server<BytesPacket, BytesPacket> {
Server::bind_with_config("127.0.0.1:0".parse().expect("addr"), config).expect("bind")
}
fn connect_and_accept(net: &Server<BytesPacket, BytesPacket>) -> (StdTcpStream, ServerClient) {
let stream = StdTcpStream::connect(net.local_addr()).expect("connect");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => return (stream, client),
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
other => panic!("timed out waiting for accept: {other:?}"),
}
}
}
fn read_packet(stream: &mut StdTcpStream) -> io::Result<BytesPacket> {
BytesPacket::read(stream)
}
fn wait_lost<I, O>(net: &Server<I, O>, client: ServerClient)
where
I: PacketIn + Send + 'static,
O: PacketOut + Send + 'static,
{
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Lost { client: got, .. }) if got == client => return,
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
_other => panic!("timed out waiting for lost"),
}
}
}
fn wait_lost_error<I, O>(net: &Server<I, O>, client: ServerClient) -> io::Error
where
I: PacketIn + Send + 'static,
O: PacketOut + Send + 'static,
{
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Lost {
client: got,
error: Some(error),
}) if got == client => return error,
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
_ => panic!("timed out waiting for lost error"),
}
}
}
fn poll_until_none(net: &Server<BytesPacket, BytesPacket>) {
while net.poll().expect("poll").is_some() {}
}
fn write_packet(stream: &mut StdTcpStream, packet: &BytesPacket) -> io::Result<()> {
packet.write(stream)
}
fn wait_poll_error<I, O>(net: &Server<I, O>)
where
I: PacketIn + Send + 'static,
O: PacketOut + Send + 'static,
{
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll() {
Ok(_) if Instant::now() < deadline => thread::sleep(Duration::from_millis(1)),
Err(_) => return,
_other => panic!("timed out waiting for poll error"),
}
}
}
#[test]
fn full_send_queue_does_not_block_disconnect() {
let config = ServerConfig {
command_queue_limit: 1,
..ServerConfig::default()
};
let net = test_net(config);
let (_stream, client) = connect_and_accept(&net);
let mut saw_full = false;
for _ in 0..10_000 {
match net.send(client, BytesPacket(vec![1])) {
Ok(()) => {}
Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
saw_full = true;
break;
}
Err(e) => panic!("unexpected send error: {e}"),
}
}
assert!(saw_full);
net.disconnect(client)
.expect("disconnect should use the priority control queue");
let _ = net.shutdown();
}
#[test]
fn event_queue_overflow_applies_backpressure_without_stopping_server() {
let net = test_net(ServerConfig {
event_queue_limit: 1,
..ServerConfig::default()
});
let _first = StdTcpStream::connect(net.local_addr()).expect("first connect");
let _second = StdTcpStream::connect(net.local_addr()).expect("second connect");
thread::sleep(Duration::from_millis(50));
let mut accepted = Vec::new();
let deadline = Instant::now() + Duration::from_secs(2);
while accepted.len() < 2 {
match net.poll() {
Ok(Some(ServerEvent::Accept { client, .. })) => accepted.push(client),
Ok(_) if Instant::now() < deadline => thread::sleep(Duration::from_millis(1)),
other => panic!("timed out waiting for accepts: {other:?}"),
}
}
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn prebound_listener_reports_peer_address() {
let listener = StdTcpListener::bind("127.0.0.1:0").expect("bind listener");
let addr = listener.local_addr().expect("listener address");
let net = Server::<BytesPacket, BytesPacket>::from_listener_with_config(
listener,
ServerConfig {
nodelay: false,
keepalive_time: None,
..ServerConfig::default()
},
)
.expect("start from listener");
assert_eq!(net.local_addr(), addr);
let stream = StdTcpStream::connect(addr).expect("connect");
let expected_peer = stream.local_addr().expect("client local address");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept {
client: _,
peer_addr,
}) => {
assert_eq!(peer_addr, expected_peer);
break;
}
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
event => panic!("timed out waiting for accept: {event:?}"),
}
}
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn full_event_queue_does_not_block_output_flush() {
let net = test_net(ServerConfig {
event_queue_limit: 1,
max_clients: 1,
idle_timeout: None,
packet_assembly_timeout: None,
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
write_packet(&mut stream, &BytesPacket(b"first".to_vec())).expect("write first");
write_packet(&mut stream, &BytesPacket(b"second".to_vec())).expect("write second");
thread::sleep(Duration::from_millis(50));
net.send(client, BytesPacket(b"reply".to_vec()))
.expect("queue reply while events are full");
assert_eq!(
read_packet(&mut stream).expect("read reply"),
BytesPacket(b"reply".to_vec())
);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn full_event_queue_does_not_block_graceful_disconnect() {
let net = test_net(ServerConfig {
event_queue_limit: 1,
max_clients: 1,
idle_timeout: None,
packet_assembly_timeout: None,
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
write_packet(&mut stream, &BytesPacket(b"first".to_vec())).expect("write first");
write_packet(&mut stream, &BytesPacket(b"second".to_vec())).expect("write second");
thread::sleep(Duration::from_millis(50));
net.send(client, BytesPacket(b"goodbye".to_vec()))
.expect("queue goodbye");
net.disconnect(client)
.expect("disconnect while events are full");
assert_eq!(
read_packet(&mut stream).expect("read goodbye"),
BytesPacket(b"goodbye".to_vec())
);
let error = read_packet(&mut stream).expect_err("connection should close");
assert_eq!(error.kind(), io::ErrorKind::UnexpectedEof);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn full_event_queue_does_not_block_idle_timeout() {
let net = test_net(ServerConfig {
event_queue_limit: 1,
max_clients: 2,
idle_timeout: Some(Duration::from_millis(50)),
packet_assembly_timeout: None,
..ServerConfig::default()
});
let (mut busy_stream, _busy_client) = connect_and_accept(&net);
let (mut idle_stream, _idle_client) = connect_and_accept(&net);
idle_stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
write_packet(&mut busy_stream, &BytesPacket(b"first".to_vec())).expect("write first");
write_packet(&mut busy_stream, &BytesPacket(b"second".to_vec())).expect("write second");
thread::sleep(Duration::from_millis(200));
let mut byte = [0];
assert_eq!(idle_stream.read(&mut byte).expect("read closed socket"), 0);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn full_event_queue_does_not_block_shutdown() {
let net = test_net(ServerConfig {
event_queue_limit: 1,
max_clients: 1,
idle_timeout: None,
packet_assembly_timeout: None,
..ServerConfig::default()
});
let (mut stream, _client) = connect_and_accept(&net);
write_packet(&mut stream, &BytesPacket(b"first".to_vec())).expect("write first");
write_packet(&mut stream, &BytesPacket(b"second".to_vec())).expect("write second");
thread::sleep(Duration::from_millis(50));
let shutdown_net = net.clone();
let (sender, receiver) = mpsc::channel();
let shutdown = thread::spawn(move || {
sender
.send(shutdown_net.shutdown_and_wait())
.expect("send shutdown result");
});
receiver
.recv_timeout(Duration::from_secs(2))
.expect("shutdown timed out")
.expect("shutdown failed");
shutdown.join().expect("join shutdown");
}
#[test]
fn protocol_error_response_uses_priority_output_path() {
let net = Server::<InvalidPacket, BytesPacket>::bind_with_config_and_protocol_error(
"127.0.0.1:0".parse().expect("addr"),
ServerConfig {
command_queue_limit: 1,
..ServerConfig::default()
},
|_e| BytesPacket(b"protocol-error".to_vec()),
)
.expect("bind");
let mut stream = StdTcpStream::connect(net.local_addr()).expect("connect");
let client = loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => break client,
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
};
let mut saw_full = false;
for _ in 0..10_000 {
match net.send(client, BytesPacket(b"queued".to_vec())) {
Ok(()) => {}
Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
saw_full = true;
break;
}
Err(e) => panic!("unexpected send error: {e}"),
}
}
assert!(saw_full);
stream.write_all(&[0xFF]).expect("write invalid");
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
let mut saw_protocol_error = false;
for _ in 0..256 {
match read_packet(&mut stream) {
Ok(BytesPacket(bytes)) if bytes == b"protocol-error" => {
saw_protocol_error = true;
break;
}
Ok(_) => {}
Err(e)
if matches!(
e.kind(),
io::ErrorKind::WouldBlock
| io::ErrorKind::TimedOut
| io::ErrorKind::UnexpectedEof
) =>
{
break;
}
Err(e) => panic!("unexpected read error: {e}"),
}
}
assert!(saw_protocol_error);
wait_lost(&net, client);
net.shutdown().expect("shutdown");
}
#[test]
fn invalid_packet_generates_one_protocol_error_response() {
let calls = Arc::new(AtomicUsize::new(0));
let calls_for_hook = Arc::clone(&calls);
let net = Server::<InvalidPacket, BytesPacket>::bind_with_config_and_protocol_error(
"127.0.0.1:0".parse().expect("addr"),
ServerConfig::default(),
move |_e| {
calls_for_hook.fetch_add(1, AtomicOrdering::Relaxed);
BytesPacket(b"protocol-error".to_vec())
},
)
.expect("bind");
let mut stream = StdTcpStream::connect(net.local_addr()).expect("connect");
let client = loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => break client,
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
};
stream
.write_all(&[0xFF, 0xFE, 0xFD])
.expect("write invalid");
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
assert_eq!(
read_packet(&mut stream).expect("read protocol error"),
BytesPacket(b"protocol-error".to_vec())
);
wait_lost(&net, client);
assert_eq!(calls.load(AtomicOrdering::Relaxed), 1);
net.shutdown().expect("shutdown");
}
#[test]
fn shutdown_closes_connected_clients() {
let net = test_net(ServerConfig::default());
let (_, client) = connect_and_accept(&net);
net.shutdown().expect("shutdown");
wait_lost(&net, client);
}
#[test]
fn shutdown_is_ok_after_poll_thread_already_stopped() {
let net = test_net(ServerConfig::default());
net.shutdown_and_wait().expect("initial shutdown");
wait_poll_error(&net);
net.shutdown_and_wait().expect("repeated shutdown");
}
#[test]
fn decoder_cursor_position_controls_consumed_bytes() {
let net = Server::<OneBytePacket, OneBytePacket>::bind("127.0.0.1:0".parse().expect("addr"))
.expect("bind");
let mut stream = StdTcpStream::connect(net.local_addr()).expect("connect");
let client = loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => break client,
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
};
stream.write_all(&[7, 9]).expect("write packets");
let mut packets = Vec::new();
let deadline = Instant::now() + Duration::from_secs(2);
while packets.len() < 2 && Instant::now() < deadline {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client: got,
packet,
}) if got == client => packets.push(packet),
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
}
assert_eq!(packets, vec![OneBytePacket(7), OneBytePacket(9)]);
net.shutdown().expect("shutdown");
}
#[test]
fn half_close_flushes_already_queued_output_then_closes() {
let net = test_net(ServerConfig::default());
let (mut stream, client) = connect_and_accept(&net);
net.send(client, BytesPacket(b"before-eof".to_vec()))
.expect("send");
stream.shutdown(Shutdown::Write).expect("client half-close");
assert_eq!(
read_packet(&mut stream).expect("read packet"),
BytesPacket(b"before-eof".to_vec())
);
wait_lost(&net, client);
net.shutdown().expect("shutdown");
}
#[test]
fn half_close_with_no_pending_output_closes() {
let net = test_net(ServerConfig::default());
let (stream, client) = connect_and_accept(&net);
stream.shutdown(Shutdown::Write).expect("client half-close");
wait_lost(&net, client);
net.send(client, BytesPacket(b"late".to_vec()))
.expect("stale send command can still be accepted");
net.shutdown().expect("shutdown");
}
#[test]
fn idle_client_is_disconnected_with_timeout_error() {
let net = test_net(ServerConfig {
idle_timeout: Some(Duration::from_millis(25)),
..ServerConfig::default()
});
let (_stream, client) = connect_and_accept(&net);
let error = wait_lost_error(&net, client);
assert_eq!(error.kind(), io::ErrorKind::TimedOut);
assert_eq!(error.to_string(), "client idle timeout elapsed");
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn trickled_packet_fragments_do_not_extend_assembly_deadline() {
let net = test_net(ServerConfig {
idle_timeout: None,
packet_assembly_timeout: Some(Duration::from_millis(50)),
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream
.write_all(&100u32.to_be_bytes())
.expect("write length");
for _ in 0..8 {
thread::sleep(Duration::from_millis(15));
let _ = stream.write_all(&[1]);
}
let error = wait_lost_error(&net, client);
assert_eq!(error.kind(), io::ErrorKind::TimedOut);
assert_eq!(
error.to_string(),
"incoming packet assembly timeout elapsed"
);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn completed_packet_resets_deadline_for_following_partial_packet() {
let net = test_net(ServerConfig {
idle_timeout: None,
packet_assembly_timeout: Some(Duration::from_millis(300)),
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream.write_all(&[0, 0]).expect("write partial header");
thread::sleep(Duration::from_millis(200));
stream
.write_all(&[0, 1, 7, 0, 0])
.expect("complete first and start second packet");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client: got,
packet: BytesPacket(bytes),
}) if got == client => {
assert_eq!(bytes, vec![7]);
break;
}
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
event => panic!("timed out waiting for first packet: {event:?}"),
}
}
thread::sleep(Duration::from_millis(150));
assert!(net.poll().expect("poll").is_none());
stream
.write_all(&[0, 1, 9])
.expect("complete second packet");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client: got,
packet: BytesPacket(bytes),
}) if got == client => {
assert_eq!(bytes, vec![9]);
break;
}
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
event => panic!("timed out waiting for second packet: {event:?}"),
}
}
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn complete_packets_do_not_start_assembly_deadline() {
let net = test_net(ServerConfig {
idle_timeout: None,
packet_assembly_timeout: Some(Duration::from_millis(40)),
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
write_packet(&mut stream, &BytesPacket(vec![1])).expect("write first packet");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet { client: got, .. }) if got == client => break,
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
event => panic!("timed out waiting for packet: {event:?}"),
}
}
thread::sleep(Duration::from_millis(120));
write_packet(&mut stream, &BytesPacket(vec![2])).expect("write second packet");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client: got,
packet,
}) if got == client => {
assert_eq!(packet, BytesPacket(vec![2]));
break;
}
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
event => panic!("timed out waiting for second packet: {event:?}"),
}
}
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn packet_assembly_timeout_can_be_disabled() {
let net = test_net(ServerConfig {
idle_timeout: None,
packet_assembly_timeout: None,
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream.write_all(&[0, 0]).expect("write partial header");
thread::sleep(Duration::from_millis(150));
assert!(net.poll().expect("poll").is_none());
stream
.write_all(&[0, 1, 7])
.expect("complete pending packet");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client: got,
packet,
}) if got == client => {
assert_eq!(packet, BytesPacket(vec![7]));
break;
}
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
event => panic!("timed out waiting for completed packet: {event:?}"),
}
}
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn timeout_defaults_are_finite_and_invalid_limits_are_rejected() {
let defaults = ServerConfig::default();
assert_eq!(
defaults.idle_timeout,
Some(zonai::server::DEFAULT_IDLE_TIMEOUT)
);
assert_eq!(
defaults.packet_assembly_timeout,
Some(zonai::server::DEFAULT_PACKET_ASSEMBLY_TIMEOUT)
);
assert!(defaults.nodelay);
assert_eq!(
defaults.keepalive_time,
Some(zonai::server::DEFAULT_KEEPALIVE_TIME)
);
for config in [
ServerConfig {
idle_timeout: Some(Duration::ZERO),
..ServerConfig::default()
},
ServerConfig {
packet_assembly_timeout: Some(Duration::ZERO),
..ServerConfig::default()
},
ServerConfig {
keepalive_time: Some(Duration::ZERO),
..ServerConfig::default()
},
ServerConfig {
max_clients: usize::MAX,
..ServerConfig::default()
},
] {
let error = Server::<BytesPacket, BytesPacket>::bind_with_config(
"127.0.0.1:0".parse().expect("addr"),
config,
)
.err()
.expect("invalid configuration should be rejected");
assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
}
}
#[test]
fn final_packet_is_decoded_before_read_half_close() {
let net = test_net(ServerConfig::default());
let (mut stream, client) = connect_and_accept(&net);
write_packet(&mut stream, &BytesPacket(b"final".to_vec())).expect("write final packet");
stream.shutdown(Shutdown::Write).expect("client half-close");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client: got,
packet,
}) if got == client => {
assert_eq!(packet, BytesPacket(b"final".to_vec()));
break;
}
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
other => panic!("timed out waiting for final packet: {other:?}"),
}
}
wait_lost(&net, client);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn packet_exactly_at_incoming_limit_is_decoded() {
let net = test_net(ServerConfig {
incoming_buffer_initial: 4,
incoming_buffer_limit: 12,
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
write_packet(&mut stream, &BytesPacket(vec![7; 8])).expect("write exact-limit packet");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client: got,
packet,
}) if got == client => {
assert_eq!(packet, BytesPacket(vec![7; 8]));
break;
}
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
other => panic!("timed out waiting for exact-limit packet: {other:?}"),
}
}
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn incomplete_packet_at_incoming_limit_is_rejected() {
let net = test_net(ServerConfig {
incoming_buffer_initial: 4,
incoming_buffer_limit: 12,
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream.write_all(&9u32.to_be_bytes()).expect("write length");
stream.write_all(&[0; 8]).expect("fill incoming limit");
let error = wait_lost_error(&net, client);
assert_eq!(error.kind(), io::ErrorKind::InvalidData);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn send_accepted_but_per_client_limit_closes_client() {
let net = test_net(ServerConfig {
outgoing_buffer_limit: 4 * 1024 * 1024,
outgoing_packet_queue_limit: 64,
command_queue_limit: 128,
..ServerConfig::default()
});
let (_stream, client) = connect_and_accept(&net);
let payload = vec![7; 4 * 1024 * 1024 - 4];
for _ in 0..8 {
net.send(client, BytesPacket(payload.clone()))
.expect("send command accepted");
}
wait_lost(&net, client);
net.shutdown().expect("shutdown");
}
#[test]
fn disconnect_waits_for_queued_writes_to_flush() {
let net = test_net(ServerConfig::default());
let (mut stream, client) = connect_and_accept(&net);
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
net.send(client, BytesPacket(b"goodbye".to_vec()))
.expect("send");
net.disconnect(client).expect("disconnect");
assert_eq!(
read_packet(&mut stream).expect("read packet"),
BytesPacket(b"goodbye".to_vec())
);
wait_lost(&net, client);
net.shutdown().expect("shutdown");
}
#[test]
fn disconnect_flushes_only_commands_accepted_before_it() {
let net = test_net(ServerConfig {
packet_command_budget: 1,
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
net.send(client, BytesPacket(b"first".to_vec()))
.expect("send first");
net.send(client, BytesPacket(b"second".to_vec()))
.expect("send second");
net.disconnect(client).expect("disconnect");
net.send(client, BytesPacket(b"late".to_vec()))
.expect("late command can enter the server queue");
assert_eq!(
read_packet(&mut stream).expect("read first"),
BytesPacket(b"first".to_vec())
);
assert_eq!(
read_packet(&mut stream).expect("read second"),
BytesPacket(b"second".to_vec())
);
let error = read_packet(&mut stream).expect_err("connection should close before late packet");
assert_eq!(error.kind(), io::ErrorKind::UnexpectedEof);
wait_lost(&net, client);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn send_after_disconnect_is_rejected_before_encoding() {
let net = Server::<BytesPacket, CountingPacket>::bind_with_config(
"127.0.0.1:0".parse().expect("addr"),
ServerConfig {
packet_command_budget: 1,
write_byte_budget: 1,
..ServerConfig::default()
},
)
.expect("bind");
let _stream = StdTcpStream::connect(net.local_addr()).expect("connect");
let client = loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => break client,
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
};
let encodes = Arc::new(AtomicUsize::new(0));
net.send(
client,
CountingPacket {
encodes: Arc::clone(&encodes),
payload_len: 128,
},
)
.expect("send prior packet");
net.disconnect(client).expect("disconnect");
net.send(
client,
CountingPacket {
encodes: Arc::clone(&encodes),
payload_len: 1,
},
)
.expect("late command can enter the server queue");
wait_lost(&net, client);
assert_eq!(encodes.load(AtomicOrdering::Relaxed), 1);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn protocol_error_rejects_sends_queued_while_hook_runs() {
let hook_started = Arc::new(AtomicBool::new(false));
let release_hook = Arc::new(AtomicBool::new(false));
let hook_started_for_hook = Arc::clone(&hook_started);
let release_hook_for_hook = Arc::clone(&release_hook);
let net = Server::<InvalidPacket, BytesPacket>::bind_with_protocol_error(
"127.0.0.1:0".parse().expect("addr"),
move |_error| {
hook_started_for_hook.store(true, AtomicOrdering::Release);
while !release_hook_for_hook.load(AtomicOrdering::Acquire) {
thread::yield_now();
}
BytesPacket(b"protocol-error".to_vec())
},
)
.expect("bind");
let mut stream = StdTcpStream::connect(net.local_addr()).expect("connect");
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
let client = loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => break client,
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
};
stream.write_all(&[0xFF]).expect("write invalid packet");
let deadline = Instant::now() + Duration::from_secs(2);
while !hook_started.load(AtomicOrdering::Acquire) {
assert!(Instant::now() < deadline, "protocol hook did not start");
thread::yield_now();
}
net.send(client, BytesPacket(b"late".to_vec()))
.expect("late command can enter the server queue");
release_hook.store(true, AtomicOrdering::Release);
assert_eq!(
read_packet(&mut stream).expect("read protocol error"),
BytesPacket(b"protocol-error".to_vec())
);
let error = read_packet(&mut stream).expect_err("connection should close before late packet");
assert_eq!(error.kind(), io::ErrorKind::UnexpectedEof);
wait_lost(&net, client);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn disconnect_now_discards_queued_writes() {
let net = test_net(ServerConfig::default());
let (mut stream, client) = connect_and_accept(&net);
stream
.set_read_timeout(Some(Duration::from_millis(250)))
.expect("timeout");
net.send(client, BytesPacket(b"discarded".to_vec()))
.expect("send");
net.disconnect_now(client).expect("disconnect now");
let _ = read_packet(&mut stream);
wait_lost(&net, client);
net.shutdown().expect("shutdown");
}
#[test]
fn oversized_outgoing_packet_is_rejected_before_unbounded_growth() {
let net = test_net(ServerConfig {
outgoing_buffer_limit: 8,
..ServerConfig::default()
});
let (_stream, client) = connect_and_accept(&net);
net.send(client, BytesPacket(vec![1; 16]))
.expect("queue send");
wait_lost(&net, client);
poll_until_none(&net);
#[cfg(feature = "stats")]
assert_eq!(net.stats().packets_sent, 0);
net.shutdown().expect("shutdown");
}
#[test]
fn zero_byte_outgoing_packet_closes_client_with_error() {
let net = Server::<BytesPacket, EmptyPacket>::bind("127.0.0.1:0".parse().expect("addr"))
.expect("bind");
let _stream = StdTcpStream::connect(net.local_addr()).expect("connect");
let client = loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => break client,
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
};
net.send(client, EmptyPacket).expect("queue empty packet");
let error = wait_lost_error(&net, client);
assert_eq!(error.kind(), io::ErrorKind::InvalidData);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn global_outgoing_limit_rejects_packet_before_queueing() {
let net = test_net(ServerConfig {
outgoing_buffer_limit: 1024,
global_outgoing_buffer_limit: 8,
..ServerConfig::default()
});
let (_stream, client) = connect_and_accept(&net);
net.send(client, BytesPacket(vec![1; 16]))
.expect("queue packet command");
let error = wait_lost_error(&net, client);
assert_eq!(error.kind(), io::ErrorKind::OutOfMemory);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn stale_client_handle_does_not_send_to_reused_token() {
let net = test_net(ServerConfig::default());
let (stream1, stale) = connect_and_accept(&net);
net.disconnect(stale).expect("disconnect");
stream1.shutdown(Shutdown::Both).expect("client close");
wait_lost(&net, stale);
let (mut stream2, current) = connect_and_accept(&net);
net.send(stale, BytesPacket(b"stale".to_vec()))
.expect("stale send command can be queued");
net.send(current, BytesPacket(b"current".to_vec()))
.expect("current send");
stream2
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
assert_eq!(
read_packet(&mut stream2).expect("read current"),
BytesPacket(b"current".to_vec())
);
net.shutdown().expect("shutdown");
}
#[test]
fn slow_reader_receives_queued_packets() {
let net = test_net(ServerConfig {
outgoing_buffer_limit: 4 * 1024 * 1024,
outgoing_packet_queue_limit: 256,
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream
.set_read_timeout(Some(Duration::from_secs(5)))
.expect("timeout");
for n in 0..64u8 {
net.send(client, BytesPacket(vec![n; 8 * 1024]))
.expect("queue packet");
}
thread::sleep(Duration::from_millis(100));
for n in 0..64u8 {
assert_eq!(
read_packet(&mut stream).expect("read packet"),
BytesPacket(vec![n; 8 * 1024])
);
}
net.shutdown().expect("shutdown");
}
#[test]
fn partial_writes_are_buffered_until_reader_catches_up() {
let net = test_net(ServerConfig {
outgoing_buffer_limit: 16 * 1024 * 1024,
outgoing_packet_queue_limit: 128,
..ServerConfig::default()
});
let (mut stream, client) = connect_and_accept(&net);
stream
.set_read_timeout(Some(Duration::from_secs(10)))
.expect("timeout");
for n in 0..32u8 {
net.send(client, BytesPacket(vec![n; 256 * 1024]))
.expect("queue packet");
}
thread::sleep(Duration::from_millis(250));
for n in 0..32u8 {
assert_eq!(
read_packet(&mut stream).expect("read packet"),
BytesPacket(vec![n; 256 * 1024])
);
}
net.shutdown().expect("shutdown");
}
#[test]
fn command_drain_works_with_mixed_socket_and_waker_events() {
let net = test_net(ServerConfig::default());
let (mut stream, client) = connect_and_accept(&net);
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
write_packet(&mut stream, &BytesPacket(b"inbound".to_vec())).expect("write inbound");
net.send(client, BytesPacket(b"outbound".to_vec()))
.expect("send outbound");
let mut saw_inbound = false;
let deadline = Instant::now() + Duration::from_secs(2);
while !saw_inbound && Instant::now() < deadline {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client: got,
packet,
}) if got == client && packet == BytesPacket(b"inbound".to_vec()) => {
saw_inbound = true;
}
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
}
assert!(saw_inbound);
assert_eq!(
read_packet(&mut stream).expect("read outbound"),
BytesPacket(b"outbound".to_vec())
);
net.shutdown().expect("shutdown");
}
#[test]
fn hot_reader_does_not_starve_another_ready_client() {
let net = Server::<OneBytePacket, OneBytePacket>::bind_with_config(
"127.0.0.1:0".parse().expect("addr"),
ServerConfig {
event_queue_limit: 2,
packet_decode_budget: 1,
read_byte_budget: 1024,
..ServerConfig::default()
},
)
.expect("bind");
let mut hot = StdTcpStream::connect(net.local_addr()).expect("connect hot client");
let mut other = StdTcpStream::connect(net.local_addr()).expect("connect other client");
thread::sleep(Duration::from_millis(50));
hot.write_all(&[1; 128]).expect("write hot packets");
other.write_all(&[9]).expect("write other packet");
let deadline = Instant::now() + Duration::from_secs(2);
let mut hot_packets_before_other = 0;
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
packet: OneBytePacket(9),
..
}) => break,
Some(ServerEvent::Packet {
packet: OneBytePacket(1),
..
}) => hot_packets_before_other += 1,
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
event => panic!("timed out waiting for other client packet: {event:?}"),
}
}
assert!(
hot_packets_before_other < 16,
"hot client produced {hot_packets_before_other} packets before the other client"
);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn hot_writer_does_not_starve_another_ready_client() {
let net = test_net(ServerConfig {
write_byte_budget: 8,
outgoing_buffer_limit: 4 * 1024 * 1024,
global_outgoing_buffer_limit: 8 * 1024 * 1024,
..ServerConfig::default()
});
let (_hot_stream, hot_client) = connect_and_accept(&net);
let (mut other_stream, other_client) = connect_and_accept(&net);
other_stream
.set_read_timeout(Some(Duration::from_secs(2)))
.expect("timeout");
net.send(hot_client, BytesPacket(vec![1; 2 * 1024 * 1024]))
.expect("queue hot write");
net.send(other_client, BytesPacket(b"other".to_vec()))
.expect("queue other write");
assert_eq!(
read_packet(&mut other_stream).expect("read other packet"),
BytesPacket(b"other".to_vec())
);
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn command_flood_does_not_starve_socket_reads() {
let net = Server::<OneBytePacket, OneBytePacket>::bind_with_config(
"127.0.0.1:0".parse().expect("addr"),
ServerConfig {
command_queue_limit: 64,
packet_command_budget: 1,
..ServerConfig::default()
},
)
.expect("bind");
let stale_stream = StdTcpStream::connect(net.local_addr()).expect("connect stale client");
let stale_client = loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => break client,
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
};
stale_stream
.shutdown(Shutdown::Both)
.expect("close stale client");
wait_lost(&net, stale_client);
let mut active_stream = StdTcpStream::connect(net.local_addr()).expect("connect active client");
let active_client = loop {
match net.poll().expect("poll") {
Some(ServerEvent::Accept { client, .. }) => break client,
Some(_) | None => thread::sleep(Duration::from_millis(1)),
}
};
let stop = Arc::new(AtomicBool::new(false));
let stop_for_producer = Arc::clone(&stop);
let producer_net = net.clone();
let producer = thread::spawn(move || {
while !stop_for_producer.load(AtomicOrdering::Relaxed) {
match producer_net.send(stale_client, OneBytePacket(1)) {
Ok(()) => {}
Err(error) if error.kind() == io::ErrorKind::WouldBlock => thread::yield_now(),
Err(_) => break,
}
}
});
active_stream.write_all(&[9]).expect("write active packet");
let deadline = Instant::now() + Duration::from_secs(2);
loop {
match net.poll().expect("poll") {
Some(ServerEvent::Packet {
client,
packet: OneBytePacket(9),
}) if client == active_client => break,
Some(_) | None if Instant::now() < deadline => {
thread::sleep(Duration::from_millis(1));
}
event => panic!("timed out waiting for active packet: {event:?}"),
}
}
stop.store(true, AtomicOrdering::Relaxed);
producer.join().expect("join producer");
net.shutdown_and_wait().expect("shutdown");
}
#[test]
fn accept_backlog_does_not_delay_shutdown() {
let net = test_net(ServerConfig {
accept_budget: 1,
..ServerConfig::default()
});
let addr = net.local_addr();
let connections = thread::spawn(move || {
(0..64)
.filter_map(|_| StdTcpStream::connect(addr).ok())
.collect::<Vec<_>>()
});
thread::sleep(Duration::from_millis(10));
let shutdown_net = net.clone();
let (shutdown_sender, shutdown_receiver) = mpsc::channel();
let shutdown = thread::spawn(move || {
shutdown_sender
.send(shutdown_net.shutdown_and_wait())
.expect("send shutdown result");
});
shutdown_receiver
.recv_timeout(Duration::from_secs(2))
.expect("shutdown timed out")
.expect("shutdown failed");
shutdown.join().expect("join shutdown");
drop(connections.join().expect("join connections"));
}
#[cfg(feature = "serde")]
#[test]
fn server_config_implements_serde_traits() {
fn assert_serialize<T: serde::Serialize>() {}
fn assert_deserialize<T: serde::de::DeserializeOwned>() {}
assert_serialize::<ServerConfig>();
assert_deserialize::<ServerConfig>();
}