#![cfg(feature = "net")]
use std::{
io::{self, BufRead, BufReader, Write},
net::{TcpListener, TcpStream},
sync::mpsc,
thread,
time::{Duration, Instant},
};
use rpc_io::{Framing, Router, Server};
fn listener() -> (TcpListener, std::net::SocketAddr) {
let listener = match TcpListener::bind("127.0.0.1:0") {
Ok(listener) => listener,
Err(error) => panic!("{error}"),
};
let addr = match listener.local_addr() {
Ok(addr) => addr,
Err(error) => panic!("{error}"),
};
(listener, addr)
}
fn ask(client: &mut TcpStream, reader: &mut BufReader<TcpStream>, body: &str) -> String {
assert!(client.write_all(body.as_bytes()).is_ok());
assert!(client.write_all(b"\n").is_ok());
let mut line = String::new();
assert!(reader.read_line(&mut line).is_ok());
line
}
fn closed(reader: &mut impl BufRead) -> bool {
let mut rest = String::new();
match reader.read_line(&mut rest) {
Ok(0) => true,
Ok(_) => false,
Err(error) => matches!(
error.kind(),
io::ErrorKind::ConnectionReset | io::ErrorKind::ConnectionAborted
),
}
}
fn connect(addr: std::net::SocketAddr) -> (TcpStream, BufReader<TcpStream>) {
let client = match TcpStream::connect(addr) {
Ok(client) => client,
Err(error) => panic!("{error}"),
};
let _timeout = client.set_read_timeout(Some(Duration::from_secs(10)));
let reader = match client.try_clone() {
Ok(reader) => BufReader::new(reader),
Err(error) => panic!("{error}"),
};
(client, reader)
}
#[test]
fn test_tcp_server_serves_connections_with_their_own_state_and_stops() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline);
let stopper = server.stopper();
let (seen, connections) = mpsc::channel();
let serving = thread::spawn(move || {
server.serve_tcp(listener, move |connection| {
let _sent = seen.send(connection.clone());
let router = Router::new().request("whoami", |me: &mut u64, _, _| Ok(*me));
(router, connection.id)
})
});
let mut clients: Vec<_> = (0..3).map(|_| connect(addr)).collect();
let mut answers = Vec::new();
for (client, reader) in &mut clients {
answers.push(ask(
client,
reader,
r#"{"jsonrpc":"2.0","id":1,"method":"whoami"}"#,
));
}
answers.sort();
assert_eq!(
answers,
[
"{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":0}\n",
"{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":1}\n",
"{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":2}\n",
]
);
let first = connections.recv_timeout(Duration::from_secs(5));
assert!(first.is_ok_and(|c| c.id == 0 && c.addr.starts_with("127.0.0.1:")));
let started = Instant::now();
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
assert!(
started.elapsed() < Duration::from_secs(30),
"stopping took {:?}",
started.elapsed()
);
for (_client, reader) in &mut clients {
assert!(closed(reader));
}
assert!(stopper.is_stopped());
}
#[test]
fn test_tcp_server_bounds_its_connections() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline).with_max_connections(1);
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new().request("ping", |_: &mut (), _, _| Ok("pong")),
(),
)
})
});
let (mut a, mut a_reader) = connect(addr);
assert!(
ask(
&mut a,
&mut a_reader,
r#"{"jsonrpc":"2.0","id":1,"method":"ping"}"#
)
.contains("pong")
);
let (mut b, b_reader) = connect(addr);
assert!(
b.write_all(b"{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"ping\"}\n")
.is_ok()
);
let (answered, answer) = mpsc::channel();
let waiting = thread::spawn(move || {
let mut reader = b_reader;
let mut line = String::new();
let _read = reader.read_line(&mut line);
let _sent = answered.send(line);
});
assert!(answer.recv_timeout(Duration::from_millis(300)).is_err());
drop((a, a_reader));
let line = answer.recv_timeout(Duration::from_secs(10));
assert!(line.is_ok_and(|l| l.contains("pong")));
assert!(waiting.join().is_ok());
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}
#[test]
fn test_server_stopped_before_it_serves_returns_at_once() {
let (listener, _addr) = listener();
let server = Server::new(Framing::ContentLength);
server.stopper().stop();
let started = Instant::now();
assert!(
server
.serve_tcp(listener, |_| (Router::<()>::new(), ()))
.is_ok()
);
assert!(started.elapsed() < Duration::from_secs(1));
assert_eq!(server.connections(), 0);
let configured = Server::new(Framing::Newline)
.with_config(rpc_io::Config::new().with_limits(rpc_io::Limits::network()))
.with_queue(rpc_io::QueueLimits::new().with_max_bytes(1 << 20))
.with_max_connections(0);
assert_eq!(configured.max_connections(), 1);
assert_eq!(configured.config().limits, rpc_io::Limits::network());
assert_eq!(configured.queue().max_bytes, 1 << 20);
let timed = Server::new(Framing::Newline)
.with_message_timeout(Some(Duration::from_secs(5)))
.with_idle_timeout(None);
assert_eq!(timed.message_timeout(), Some(Duration::from_secs(5)));
assert_eq!(timed.idle_timeout(), None);
assert_eq!(server.config().limits, rpc_io::Limits::network());
assert_eq!(server.queue().max_bytes, 8 << 20);
assert_eq!(server.message_timeout(), Some(Duration::from_secs(30)));
assert_eq!(server.idle_timeout(), Some(Duration::from_secs(300)));
assert!(format!("{server:?} {:?}", server.stopper()).contains("max_connections: 256"));
}
#[cfg(unix)]
#[test]
fn test_unix_server_serves_and_stops() {
use std::os::unix::net::{UnixListener, UnixStream};
let path = std::env::temp_dir().join(format!("rpc-io-test-{}.sock", std::process::id()));
let _stale = std::fs::remove_file(&path);
let listener = match UnixListener::bind(&path) {
Ok(listener) => listener,
Err(error) => panic!("{error}"),
};
let server = Server::new(Framing::Newline);
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_unix(listener, |_| {
(
Router::new().request("ping", |_: &mut (), _, _| Ok("pong")),
(),
)
})
});
let mut client = match UnixStream::connect(&path) {
Ok(client) => client,
Err(error) => panic!("{error}"),
};
assert!(
client
.write_all(b"{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"ping\"}\n")
.is_ok()
);
let mut line = String::new();
let reader = client.try_clone().map(BufReader::new);
assert!(reader.is_ok_and(|mut r| r.read_line(&mut line).is_ok()));
assert_eq!(line, "{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":\"pong\"}\n");
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
let _removed = std::fs::remove_file(&path);
}
#[test]
fn test_silent_sockets_cannot_lock_out_a_client() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline)
.with_max_connections(4)
.with_message_timeout(Some(Duration::from_secs(1)));
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new().request("ping", |_: &mut (), _, _| Ok("pong")),
(),
)
})
});
let mut silent = Vec::new();
for i in 0..4 {
let (mut socket, _reader) = connect(addr);
if i % 2 == 0 {
assert!(socket.write_all(b"{").is_ok()); }
silent.push(socket);
}
let started = Instant::now();
let (mut client, mut reader) = connect(addr);
let answer = ask(
&mut client,
&mut reader,
r#"{"jsonrpc":"2.0","id":1,"method":"ping"}"#,
);
assert_eq!(
answer,
"{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":\"pong\"}\n"
);
assert!(
started.elapsed() < Duration::from_secs(30),
"{:?}",
started.elapsed()
);
for socket in silent {
let _timeout = socket.set_read_timeout(Some(Duration::from_secs(30)));
assert!(closed(&mut BufReader::new(socket)));
}
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}
#[test]
fn test_a_client_streaming_past_the_message_deadline_is_served() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline).with_message_timeout(Some(Duration::from_secs(1)));
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new().request("ping", |_: &mut (), _, _| Ok("pong")),
(),
)
})
});
let (mut client, mut reader) = connect(addr);
let count = 300;
let wire: Vec<u8> = (0..count)
.flat_map(|id| {
format!(
"{{\"jsonrpc\":\"2.0\",\"id\":{id},\"method\":\"ping\"}}
"
)
.into_bytes()
})
.collect();
let chunk = wire.len() * 3 / (2 * count);
let writer = thread::spawn(move || {
for piece in wire.chunks(chunk) {
if client.write_all(piece).is_err() {
return false;
}
thread::sleep(Duration::from_millis(20));
}
true
});
let started = Instant::now();
let mut answered = 0;
let mut line = String::new();
while answered < count {
line.clear();
match reader.read_line(&mut line) {
Ok(n) if n > 0 => {
assert!(line.contains("pong"), "{line}");
answered += 1;
}
other => panic!(
"cut off after {answered} answers at {:?}: {other:?}",
started.elapsed()
),
}
}
assert!(writer.join().is_ok_and(|wrote| wrote));
assert!(
started.elapsed() > Duration::from_secs(2),
"{:?}",
started.elapsed()
);
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}
#[test]
fn test_a_client_waiting_on_an_answer_is_not_idle() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline).with_idle_timeout(Some(Duration::from_millis(300)));
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new().deferred("slow", |_: &mut (), _, _, responder| {
thread::spawn(move || {
thread::sleep(Duration::from_millis(1200));
let _answered = responder.ok("done");
});
}),
(),
)
})
});
let (mut client, mut reader) = connect(addr);
let answer = ask(
&mut client,
&mut reader,
r#"{"jsonrpc":"2.0","id":1,"method":"slow"}"#,
);
assert_eq!(
answer,
"{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":\"done\"}
"
);
let started = Instant::now();
assert!(closed(&mut reader), "the connection stayed open");
assert!(
started.elapsed() < Duration::from_secs(30),
"{:?}",
started.elapsed()
);
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}
#[test]
fn test_a_client_that_never_answers_our_request_still_goes_idle() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline).with_idle_timeout(Some(Duration::from_millis(300)));
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new().notification("hello", |_: &mut (), _, cx| {
if let Ok(call) = cx.request("question", ()) {
call.detach();
}
}),
(),
)
})
});
let (mut client, mut reader) = connect(addr);
assert!(
client
.write_all(
b"{\"jsonrpc\":\"2.0\",\"method\":\"hello\"}
"
)
.is_ok()
);
let mut line = String::new();
assert!(reader.read_line(&mut line).is_ok_and(|n| n > 0));
assert!(line.contains("question"), "{line}");
let started = Instant::now();
assert!(closed(&mut reader), "the connection stayed open");
assert!(
started.elapsed() < Duration::from_secs(30),
"{:?}",
started.elapsed()
);
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}
#[test]
fn test_idle_and_unfinished_connections_are_closed() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline)
.with_message_timeout(Some(Duration::from_secs(1)))
.with_idle_timeout(Some(Duration::from_secs(1)));
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new().request("ping", |_: &mut (), _, _| Ok("pong")),
(),
)
})
});
let (mut client, mut reader) = connect(addr);
assert!(
ask(
&mut client,
&mut reader,
r#"{"jsonrpc":"2.0","id":1,"method":"ping"}"#
)
.contains("pong")
);
let started = Instant::now();
assert!(closed(&mut reader));
let idle = started.elapsed();
assert!(
idle >= Duration::from_millis(250) && idle < Duration::from_secs(30),
"{idle:?}"
);
let (mut slow, mut slow_reader) = connect(addr);
let message = br#"{"jsonrpc":"2.0","id":2,"method":"ping"}"#;
let trickle = thread::spawn(move || {
for byte in message.iter() {
if slow.write_all(&[*byte]).is_err() {
return;
}
thread::sleep(Duration::from_millis(50));
}
let _end = slow.write_all(b"\n");
});
assert!(closed(&mut slow_reader));
assert!(trickle.join().is_ok());
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}
#[test]
fn test_a_client_cannot_hold_a_connection_through_a_request_that_waits_on_it() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline).with_idle_timeout(Some(Duration::from_millis(300)));
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new().deferred(
"tools/call",
|held: &mut Vec<(rpc_io::Call, rpc_io::Responder)>, _, cx, responder| {
if let Ok(call) = cx.request("sampling/createMessage", ()) {
held.push((call, responder));
}
},
),
Vec::new(),
)
})
});
let (mut client, mut reader) = connect(addr);
assert!(
client
.write_all(b"{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\"}\n")
.is_ok()
);
let mut line = String::new();
assert!(reader.read_line(&mut line).is_ok_and(|n| n > 0));
assert!(line.contains("sampling/createMessage"), "{line}");
let started = Instant::now();
assert!(closed(&mut reader), "the connection stayed open");
assert!(
started.elapsed() < Duration::from_secs(5),
"{:?}",
started.elapsed()
);
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}
#[test]
fn test_a_byte_per_idle_period_does_not_hold_a_slot() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline)
.with_max_connections(1)
.with_message_timeout(Some(Duration::from_secs(1)))
.with_idle_timeout(Some(Duration::from_secs(2)));
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new()
.request("ping", |_: &mut (), _, _| Ok("pong"))
.notification("hello", |_: &mut (), _, _| {}),
(),
)
})
});
let (mut attacker, mut attacker_reader) = connect(addr);
assert!(
attacker
.write_all(b"{\"jsonrpc\":\"2.0\",\"method\":\"hello\"}\n")
.is_ok()
);
let started = Instant::now();
let mut held = true;
while started.elapsed() < Duration::from_secs(6) {
if attacker.write_all(b"\n").is_err() {
held = false;
break;
}
thread::sleep(Duration::from_millis(500));
}
if held {
let _timeout = attacker_reader
.get_ref()
.set_read_timeout(Some(Duration::from_secs(10)));
held = !closed(&mut attacker_reader);
}
assert!(!held, "the trickling connection kept its slot");
let (mut client, mut reader) = connect(addr);
let answer = ask(
&mut client,
&mut reader,
r#"{"jsonrpc":"2.0","id":1,"method":"ping"}"#,
);
assert_eq!(
answer,
"{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":\"pong\"}\n"
);
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}
#[test]
fn test_one_address_cannot_take_every_slot() {
let (listener, addr) = listener();
let server = Server::new(Framing::Newline)
.with_max_connections(8)
.with_max_connections_per_address(Some(2));
let stopper = server.stopper();
let serving = thread::spawn(move || {
server.serve_tcp(listener, |_| {
(
Router::new().request("ping", |_: &mut (), _, _| Ok("pong")),
(),
)
})
});
let ping = r#"{"jsonrpc":"2.0","id":1,"method":"ping"}"#;
let pong = "{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":\"pong\"}\n";
let (mut a, mut a_reader) = connect(addr);
let (mut b, mut b_reader) = connect(addr);
assert_eq!(ask(&mut a, &mut a_reader, ping), pong);
assert_eq!(ask(&mut b, &mut b_reader, ping), pong);
let (mut c, mut c_reader) = connect(addr);
let _sent = c.write_all(format!("{ping}\n").as_bytes());
assert!(closed(&mut c_reader));
drop((a, a_reader));
let deadline = Instant::now() + Duration::from_secs(20);
let served = loop {
let (mut d, mut d_reader) = connect(addr);
let _sent = d.write_all(format!("{ping}\n").as_bytes());
let mut line = String::new();
if d_reader.read_line(&mut line).is_ok_and(|n| n > 0) {
break line == pong;
}
if Instant::now() > deadline {
break false;
}
thread::sleep(Duration::from_millis(50));
};
assert!(served);
stopper.stop();
assert!(serving.join().is_ok_and(|served| served.is_ok()));
}