use std::cell::Cell;
use std::io::{self, BufReader, BufWriter, Read, Write};
use std::net::{SocketAddr, TcpListener, TcpStream, ToSocketAddrs};
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::rc::Rc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};
use crate::config::Config;
use crate::error::{Error, Result};
use crate::method::Method;
use crate::middleware::Middleware;
use crate::plugin::Plugin;
use crate::pool::ThreadPool;
use crate::request::Request;
use crate::response::Response;
use crate::router::Router;
use crate::status::Status;
const DEFAULT_MAX_BODY: usize = 2 * 1024 * 1024;
const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(30);
const DEFAULT_REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
struct App {
router: Router,
middleware: Vec<Box<dyn Middleware>>,
max_body: usize,
}
#[derive(Clone, Copy)]
struct Timeouts {
idle: Option<Duration>,
request: Option<Duration>,
}
pub struct Server {
router: Router,
middleware: Vec<Box<dyn Middleware>>,
config: Config,
workers: usize,
max_body: usize,
read_timeout: Option<Duration>,
request_timeout: Option<Duration>,
}
impl Server {
pub fn new(router: Router) -> Server {
Server {
router,
middleware: Vec::new(),
config: Config::new(),
workers: default_workers(),
max_body: DEFAULT_MAX_BODY,
read_timeout: Some(DEFAULT_READ_TIMEOUT),
request_timeout: Some(DEFAULT_REQUEST_TIMEOUT),
}
}
pub fn config(mut self, config: Config) -> Server {
self.config = config;
self
}
pub fn with<M: Middleware>(mut self, middleware: M) -> Server {
self.middleware.push(Box::new(middleware));
self
}
pub fn plugin<P: Plugin + 'static>(mut self, plugin: P) -> Server {
let config = self.config.clone();
Box::new(plugin).install(&mut self.router, &config);
self
}
pub fn workers(mut self, workers: usize) -> Server {
self.workers = workers.max(1);
self
}
pub fn max_body_bytes(mut self, bytes: usize) -> Server {
self.max_body = bytes;
self
}
pub fn read_timeout(mut self, timeout: Option<Duration>) -> Server {
self.read_timeout = timeout;
self
}
pub fn request_timeout(mut self, timeout: Option<Duration>) -> Server {
self.request_timeout = timeout;
self
}
pub fn bind<A: ToSocketAddrs>(self, addr: A) -> Result<Running> {
let listener = TcpListener::bind(addr)?;
let local_addr = listener.local_addr()?;
listener.set_nonblocking(true)?;
let app = Arc::new(App {
router: self.router,
middleware: self.middleware,
max_body: self.max_body,
});
let shutdown = Arc::new(AtomicBool::new(false));
let stop = Arc::clone(&shutdown);
let workers = self.workers;
let timeouts = Timeouts {
idle: self.read_timeout,
request: self.request_timeout,
};
let thread = thread::spawn(move || {
let pool = ThreadPool::new(workers);
while !stop.load(Ordering::Relaxed) {
match listener.accept() {
Ok((stream, peer)) => {
let app = Arc::clone(&app);
pool.execute(move || serve(stream, peer, app, timeouts));
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
thread::sleep(Duration::from_millis(2));
}
Err(_) => {
thread::sleep(Duration::from_millis(2));
}
}
}
});
Ok(Running {
addr: local_addr,
shutdown,
thread: Some(thread),
})
}
}
pub struct Running {
addr: SocketAddr,
shutdown: Arc<AtomicBool>,
thread: Option<JoinHandle<()>>,
}
impl Running {
pub fn addr(&self) -> SocketAddr {
self.addr
}
pub fn port(&self) -> u16 {
self.addr.port()
}
pub fn shutdown_handle(&self) -> Shutdown {
Shutdown {
flag: Arc::clone(&self.shutdown),
}
}
pub fn wait(mut self) {
if let Some(thread) = self.thread.take() {
let _ = thread.join();
}
}
pub fn shutdown(mut self) {
self.shutdown.store(true, Ordering::Relaxed);
if let Some(thread) = self.thread.take() {
let _ = thread.join();
}
}
}
impl Drop for Running {
fn drop(&mut self) {
self.shutdown.store(true, Ordering::Relaxed);
if let Some(thread) = self.thread.take() {
let _ = thread.join();
}
}
}
#[derive(Clone)]
pub struct Shutdown {
flag: Arc<AtomicBool>,
}
impl Shutdown {
pub fn stop(&self) {
self.flag.store(true, Ordering::Relaxed);
}
}
fn default_workers() -> usize {
let cores = thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(2);
(cores * 4).clamp(4, 256)
}
#[derive(Clone)]
struct Deadline {
limit: Option<Duration>,
expires: Rc<Cell<Option<Instant>>>,
}
impl Deadline {
fn new(limit: Option<Duration>) -> Deadline {
Deadline {
limit,
expires: Rc::new(Cell::new(None)),
}
}
fn arm(&self) {
if self.expires.get().is_some() {
return;
}
if let Some(at) = self
.limit
.and_then(|limit| Instant::now().checked_add(limit))
{
self.expires.set(Some(at));
}
}
fn clear(&self) {
self.expires.set(None);
}
fn remaining(&self) -> io::Result<Option<Duration>> {
match self.expires.get() {
None => Ok(None),
Some(at) => match at.checked_duration_since(Instant::now()) {
Some(left) if !left.is_zero() => Ok(Some(left)),
_ => Err(io::Error::new(
io::ErrorKind::TimedOut,
"request deadline exceeded",
)),
},
}
}
}
struct Timed {
stream: TcpStream,
idle: Option<Duration>,
deadline: Deadline,
}
impl Timed {
fn new(stream: TcpStream, idle: Option<Duration>, deadline: Deadline) -> Timed {
Timed {
stream,
idle,
deadline,
}
}
fn window(&self) -> io::Result<Option<Duration>> {
let window = match (self.idle, self.deadline.remaining()?) {
(Some(idle), Some(left)) => Some(idle.min(left)),
(Some(idle), None) => Some(idle),
(None, left) => left,
};
Ok(window.map(|d| {
if d.is_zero() {
Duration::from_millis(1)
} else {
d
}
}))
}
}
impl Read for Timed {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let window = self.window()?;
self.stream.set_read_timeout(window)?;
let read = self.stream.read(buf)?;
if read > 0 {
self.deadline.arm();
}
Ok(read)
}
}
impl Write for Timed {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.deadline.arm();
let window = self.window()?;
self.stream.set_write_timeout(window)?;
self.stream.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.stream.flush()
}
}
fn serve(stream: TcpStream, peer: SocketAddr, app: Arc<App>, timeouts: Timeouts) {
let _ = stream.set_nonblocking(false);
let _ = stream.set_nodelay(true);
let write_half = match stream.try_clone() {
Ok(half) => half,
Err(_) => return,
};
let deadline = Deadline::new(timeouts.request);
let mut reader = BufReader::new(Timed::new(stream, timeouts.idle, deadline.clone()));
let mut writer = BufWriter::new(Timed::new(write_half, timeouts.idle, deadline.clone()));
loop {
deadline.clear();
match Request::read_from(&mut reader, app.max_body) {
Ok(None) => break,
Ok(Some(mut request)) => {
request.peer = Some(peer);
let keep_alive = request.keep_alive();
let head_only = request.method == Method::Head;
let response = handle(&app, &mut request);
if response
.write_to(&mut writer, head_only, keep_alive)
.is_err()
{
break;
}
if !keep_alive {
break;
}
}
Err(err) => {
if !is_disconnect(&err) {
let response = error_response(&err);
let _ = response.write_to(&mut writer, false, false);
}
break;
}
}
}
}
fn handle(app: &App, request: &mut Request) -> Response {
let mut short_circuit = None;
for middleware in &app.middleware {
if let Some(response) = middleware.before(request) {
short_circuit = Some(response);
break;
}
}
let mut response = match short_circuit {
Some(response) => response,
None => {
match catch_unwind(AssertUnwindSafe(|| app.router.dispatch(request))) {
Ok(response) => response,
Err(_) => Response::error(Status::INTERNAL_SERVER_ERROR, "internal server error"),
}
}
};
for middleware in app.middleware.iter().rev() {
response = middleware.after(request, response);
}
response
}
fn is_disconnect(err: &Error) -> bool {
match err {
Error::Io(e) => matches!(
e.kind(),
io::ErrorKind::TimedOut
| io::ErrorKind::WouldBlock
| io::ErrorKind::UnexpectedEof
| io::ErrorKind::ConnectionReset
| io::ErrorKind::ConnectionAborted
| io::ErrorKind::BrokenPipe
),
_ => false,
}
}
fn error_response(err: &Error) -> Response {
match err {
Error::BodyTooLarge { .. } => {
Response::error(Status::PAYLOAD_TOO_LARGE, "request body too large")
}
Error::Unsupported(what) => Response::error(Status::NOT_IMPLEMENTED, what),
_ => Response::error(Status::BAD_REQUEST, "malformed request"),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_worker_count_is_sane() {
let n = default_workers();
assert!((4..=256).contains(&n), "got {n}");
}
#[test]
fn errors_map_to_the_right_status() {
assert_eq!(
error_response(&Error::BodyTooLarge { limit: 1 }).status,
Status::PAYLOAD_TOO_LARGE
);
assert_eq!(
error_response(&Error::Unsupported("chunked")).status,
Status::NOT_IMPLEMENTED
);
assert_eq!(
error_response(&Error::BadRequest("x".into())).status,
Status::BAD_REQUEST
);
}
#[test]
fn parse_failures_do_not_leak_detail_to_the_client() {
let res = error_response(&Error::BadRequest("secret internal detail".into()));
let body = String::from_utf8(res.into_body().into_bytes().unwrap()).unwrap();
assert!(!body.contains("secret internal detail"));
}
}