use std::collections::{HashMap, HashSet, VecDeque};
use std::io;
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use quietquic_proto::endpoint::Endpoint as Core;
use quietquic_proto::outcome::ConnectionHandle;
use quietquic_proto::outcome::Event as CoreEvent;
use tokio::net::UdpSocket;
use tokio::sync::{mpsc, watch};
use crate::config::ServerSecrets;
use crate::conn::{CmdSender, Parked, Tagged};
pub use crate::conn::{
ConnError, Connection, ConnectionError, QuinnHandle, RecvStream, SendStream,
};
const MAX_DATAGRAM: usize = 65_535;
const ACCEPT_CHANNEL_CAP: usize = 32;
const CMD_CHANNEL_CAP: usize = 256;
const IDLE_SLEEP: Duration = Duration::from_secs(3600);
pub struct Server {
local_addr: SocketAddr,
incoming: mpsc::Receiver<Connection>,
_driver: tokio::task::JoinHandle<()>,
}
impl Server {
pub async fn bind(secrets: ServerSecrets) -> io::Result<Server> {
Self::bind_with_capacity(secrets, ACCEPT_CHANNEL_CAP).await
}
async fn bind_with_capacity(
secrets: ServerSecrets,
accept_capacity: usize,
) -> io::Result<Server> {
let socket = UdpSocket::bind(secrets.listen).await?;
let local_addr = socket.local_addr()?;
let core = Core::new_server(secrets).map_err(|e| io::Error::other(e.to_string()))?;
let (tx, rx) = mpsc::channel(accept_capacity);
let handle = tokio::spawn(Driver::new(socket, core, tx).run());
Ok(Server {
local_addr,
incoming: rx,
_driver: handle,
})
}
#[cfg(test)]
pub(crate) async fn bind_with_accept_capacity(
secrets: ServerSecrets,
accept_capacity: usize,
) -> io::Result<Server> {
Self::bind_with_capacity(secrets, accept_capacity).await
}
pub fn local_addr(&self) -> SocketAddr {
self.local_addr
}
pub async fn accept(&mut self) -> Option<Connection> {
self.incoming.recv().await
}
}
struct Driver {
socket: UdpSocket,
core: Core,
parked: HashMap<ConnectionHandle, Parked>,
surfaced: HashSet<ConnectionHandle>,
accepted: mpsc::Sender<Connection>,
pending_accept: VecDeque<Connection>,
cmd_tx: mpsc::Sender<Tagged>,
cmd_rx: mpsc::Receiver<Tagged>,
}
impl Driver {
fn new(socket: UdpSocket, core: Core, accepted: mpsc::Sender<Connection>) -> Self {
let (cmd_tx, cmd_rx) = mpsc::channel(CMD_CHANNEL_CAP);
Self {
socket,
core,
parked: HashMap::new(),
surfaced: HashSet::new(),
accepted,
pending_accept: VecDeque::new(),
cmd_tx,
cmd_rx,
}
}
async fn run(mut self) {
let mut recv_buf = vec![0u8; MAX_DATAGRAM];
let accept_tx = self.accepted.clone();
loop {
self.pump().await;
let sleep = match self.core.next_timeout() {
Some(at) => tokio::time::sleep_until(tokio::time::Instant::from_std(at)),
None => tokio::time::sleep(IDLE_SLEEP),
};
tokio::pin!(sleep);
tokio::select! {
res = self.socket.recv_from(&mut recv_buf) => {
match res {
Ok((len, from)) => {
let _ = self.core.handle_datagram(
Instant::now(), from, &recv_buf[..len],
);
}
Err(_e) => continue, }
}
Some(tagged) = self.cmd_rx.recv() => {
self.on_command(tagged);
}
_ = &mut sleep => {
self.core.handle_timeout(Instant::now());
}
permit = accept_tx.reserve(), if !self.pending_accept.is_empty() => {
match permit {
Ok(permit) => {
if let Some(conn) = self.pending_accept.pop_front() {
permit.send(conn);
}
}
Err(_) => return,
}
}
_ = self.accepted.closed() => {
return; }
}
}
}
async fn pump(&mut self) {
loop {
let now = Instant::now();
let mut progressed = false;
while let Some(event) = self.core.poll_event() {
self.on_event(event);
progressed = true;
}
while let Some(transmit) = self.core.poll_transmit(now) {
let _ = self
.socket
.send_to(&transmit.contents, transmit.destination)
.await;
progressed = true;
}
if !progressed {
return;
}
}
}
fn on_event(&mut self, event: CoreEvent) {
match event {
CoreEvent::Connected(ch) => self.surface(ch),
CoreEvent::StreamOpened { conn, .. } => {
if let (Some(parked), Some(state)) =
(self.parked.get_mut(&conn), self.core.conn_mut(conn))
{
parked.on_stream_opened(state);
}
}
CoreEvent::StreamReadable { conn, id } => {
if let (Some(parked), Some(state)) =
(self.parked.get_mut(&conn), self.core.conn_mut(conn))
{
parked.on_readable(state, id);
}
}
CoreEvent::StreamWritable { conn, id } => {
if let (Some(parked), Some(state)) =
(self.parked.get_mut(&conn), self.core.conn_mut(conn))
{
parked.on_writable(state, id);
}
}
CoreEvent::StreamFinAcked { conn, id } => {
if let Some(parked) = self.parked.get_mut(&conn) {
parked.on_fin_acked(id);
}
}
CoreEvent::StreamStopped {
conn,
id,
error_code,
} => {
if let (Some(parked), Some(state)) =
(self.parked.get_mut(&conn), self.core.conn_mut(conn))
{
parked.on_stopped(state, id, error_code);
}
}
CoreEvent::ConnectionLost { conn, reason } => self.on_lost(conn, reason),
_ => {}
}
}
fn surface(&mut self, ch: ConnectionHandle) {
if !self.surfaced.insert(ch) {
return;
}
let client_id = self.core.client_id(ch).map(str::to_owned);
let Some(state) = self.core.conn_mut(ch) else {
self.surfaced.remove(&ch);
return;
};
let remote = state.conn().remote_address();
let (closed_tx, _closed_rx) = watch::channel(None);
self.parked.insert(ch, Parked::new(closed_tx));
let closed = self
.parked
.get(&ch)
.expect("parked inserted")
.subscribe_closed();
let cmds = CmdSender::new(ch, self.cmd_tx.clone());
self.pending_accept
.push_back(Connection::new(ch, remote, client_id, cmds, closed));
}
fn on_lost(&mut self, ch: ConnectionHandle, reason: ConnectionError) {
if let Some(parked) = self.parked.get(&ch) {
parked.mark_closed(reason);
}
if let Some(mut parked) = self.parked.remove(&ch) {
parked.fail_all();
}
self.surfaced.remove(&ch);
self.pending_accept.retain(|conn| conn.handle() != ch);
}
fn on_command(&mut self, tagged: Tagged) {
let ch = tagged.handle;
if let (Some(parked), Some(state)) = (self.parked.get_mut(&ch), self.core.conn_mut(ch)) {
parked.apply_cmd(state, tagged.cmd, Instant::now());
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn test_bind_addr() -> String {
let ip = std::env::var("QUIETQUIC_TEST_ADDR").unwrap_or_else(|_| "127.0.0.1".into());
let port = std::env::var("QUIETQUIC_TEST_PORT_BASE")
.ok()
.and_then(|base| base.parse::<u16>().ok())
.and_then(|base| base.checked_add(1000))
.unwrap_or(0);
format!("{ip}:{port}")
}
#[tokio::test]
async fn slow_accept_consumer_does_not_freeze_live_connections() {
use crate::client::Client;
use crate::config::ClientConfigFile;
let psk_hex = "0000000000000000000000000000000000000000000000000000000000000009";
let secrets: ServerSecrets = toml::from_str(&format!(
"listen = \"{}\"\n[[clients]]\nclient_id=\"a\"\npsk=\"{psk_hex}\"\n",
test_bind_addr()
))
.unwrap();
let mut server = Server::bind_with_accept_capacity(secrets, 1).await.unwrap();
let addr = server.local_addr();
let mk_cfg = || -> ClientConfigFile {
toml::from_str(&format!(
"client_id=\"a\"\npsk=\"{psk_hex}\"\nserver=\"{addr}\"\n"
))
.unwrap()
};
let (conn_a, client_a) = tokio::join!(server.accept(), Client::connect(mk_cfg()));
let conn_a = conn_a.expect("server accepts client A");
let client_a = client_a.expect("client A handshakes");
let client_b = Client::connect(mk_cfg())
.await
.expect("client B handshakes");
let client_c = Client::connect(mk_cfg())
.await
.expect("client C handshakes");
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
let (mut a_send, mut a_recv) = client_a.open_bi().await.expect("A opens a stream");
a_send.write_all(b"still-alive").await.expect("A writes");
a_send.finish().await.expect("A finishes");
let (mut srv_send, mut srv_recv) =
tokio::time::timeout(std::time::Duration::from_secs(10), conn_a.accept_bi())
.await
.expect("server servicing A must not be frozen by a full accept channel")
.expect("server accepts A's stream");
let got = srv_recv
.read_to_end(1024)
.await
.expect("server reads A's stream");
assert_eq!(
&got, b"still-alive",
"A's stream data must flow while B/C wait"
);
srv_send.write_all(&got).await.expect("server echoes to A");
srv_send.finish().await.expect("server finishes echo to A");
let echo =
tokio::time::timeout(std::time::Duration::from_secs(10), a_recv.read_to_end(1024))
.await
.expect("A's echo read must not time out")
.expect("A reads the echo");
assert_eq!(
&echo, b"still-alive",
"A round-trips while B/C sit undelivered"
);
let first = tokio::time::timeout(std::time::Duration::from_secs(10), server.accept())
.await
.expect("draining B must not time out")
.expect("B is delivered");
let second = tokio::time::timeout(std::time::Duration::from_secs(10), server.accept())
.await
.expect("draining C must not time out")
.expect("C is delivered once a permit frees up");
assert_ne!(
first.remote_address(),
second.remote_address(),
"B and C are delivered as two distinct connections (no drop, no double-deliver)"
);
drop((client_a, client_b, client_c));
}
}