use std::{future::Future, pin::Pin, sync::Arc, time::Duration};
use http::{HeaderValue, Method, StatusCode, header};
use hyper::body::Body as _;
use crate::{
Body, Error, IntoResponse, Middleware, Next, Request, Response, Router,
file::{RangeSource, parse_range},
middleware::{BoxMiddleware, Endpoint, Scoped, box_handler, box_middleware, catch_panic},
path::Pattern,
router::{AddRoute, Route, Table, mounted, route_methods},
state::State,
};
type ErrorHandler =
Arc<dyn Fn(Error) -> Pin<Box<dyn Future<Output = Response> + Send>> + Send + Sync>;
pub const DEFAULT_BODY_LIMIT: usize = 1024 * 1024;
pub const DEFAULT_BODY_TIMEOUT: Duration = Duration::from_secs(60);
pub struct App {
middleware: Arc<Vec<BoxMiddleware>>,
table: Arc<Table>,
state: Arc<State>,
on_error: Option<ErrorHandler>,
trust_proxy: bool,
etag: bool,
pub(crate) body_limit: usize,
pub(crate) body_timeout: Duration,
}
impl Default for App {
fn default() -> Self {
App {
middleware: Arc::default(),
table: Arc::default(),
state: Arc::default(),
on_error: None,
trust_proxy: false,
etag: true,
body_limit: DEFAULT_BODY_LIMIT,
body_timeout: DEFAULT_BODY_TIMEOUT,
}
}
}
impl App {
pub fn new() -> Self {
Self::default()
}
pub fn middleware(&mut self, middleware: impl Middleware) -> &mut Self {
Arc::make_mut(&mut self.middleware).push(box_middleware(middleware));
self
}
pub fn middleware_at(&mut self, prefix: &str, middleware: impl Middleware) -> &mut Self {
self.middleware(Scoped {
prefix: Pattern::parse(prefix),
inner: middleware,
})
}
pub fn state<T: Send + Sync + 'static>(&mut self, value: T) -> &mut Self {
Arc::make_mut(&mut self.state).insert(value);
self
}
pub fn on_error<F, Fut>(&mut self, handler: F) -> &mut Self
where
F: Fn(Error) -> Fut + Send + Sync + 'static,
Fut: Future + Send + 'static,
Fut::Output: IntoResponse,
{
self.on_error = Some(Arc::new(move |err| {
let fut = handler(err);
Box::pin(async move { fut.await.into_response() })
}));
self
}
pub fn mount(&mut self, prefix: &str, router: Router) -> &mut Self {
Arc::make_mut(&mut self.table)
.routes
.extend(mounted(prefix, router));
self
}
pub fn fallback<F, Fut>(&mut self, handler: F) -> &mut Self
where
F: Fn(Request) -> Fut + Send + Sync + 'static,
Fut: Future + Send + 'static,
Fut::Output: IntoResponse,
{
Arc::make_mut(&mut self.table).fallback = Some(box_handler(handler));
self
}
pub fn trust_proxy(&mut self, trust: bool) -> &mut Self {
self.trust_proxy = trust;
self
}
pub fn etag(&mut self, enabled: bool) -> &mut Self {
self.etag = enabled;
self
}
pub fn body_limit(&mut self, bytes: usize) -> &mut Self {
self.body_limit = bytes;
self
}
pub fn body_timeout(&mut self, timeout: Duration) -> &mut Self {
self.body_timeout = timeout;
self
}
route_methods! {
get => GET,
post => POST,
put => PUT,
patch => PATCH,
delete => DELETE,
}
pub async fn handle(&self, mut req: Request) -> Response {
let is_head = req.method() == Method::HEAD;
let req_is_get_or_head = req.method() == Method::GET || is_head;
let conditional = if req_is_get_or_head {
let headers = req.headers();
(
headers.get(header::IF_NONE_MATCH).cloned(),
headers.get(header::IF_MODIFIED_SINCE).cloned(),
)
} else {
(None, None)
};
let range = if req_is_get_or_head {
let headers = req.headers();
headers
.get(header::RANGE)
.cloned()
.map(|range| (range, headers.get(header::IF_RANGE).cloned()))
} else {
None
};
req.set_state(self.state.clone());
req.set_trust_proxy(self.trust_proxy);
let next = Next::new(
self.middleware.clone(),
Endpoint::Router(self.table.clone()),
);
let res = catch_panic(Box::pin(next.run(req))).await;
let mut res = self.finish(res).await;
if self.etag && res.status() == StatusCode::OK && req_is_get_or_head {
add_etag(&mut res);
}
if res.status() == StatusCode::OK && is_fresh(&conditional.0, &conditional.1, &res) {
not_modified(&mut res);
} else if let Some((range, if_range)) = range {
serve_range(&mut res, &range, if_range.as_ref()).await;
}
if is_head { strip_body(res) } else { res }
}
pub(crate) async fn finish(&self, res: Response) -> Response {
let (Some(handler), Some(err)) = (&self.on_error, res.extensions().get::<Error>()) else {
return res;
};
let mut custom = catch_panic(handler(err.clone())).await;
for (name, value) in res.headers() {
if name != header::CONTENT_TYPE
&& name != header::CONTENT_LENGTH
&& !custom.headers().contains_key(name)
{
custom.headers_mut().append(name, value.clone());
}
}
custom
}
}
impl AddRoute for App {
fn add_route(&mut self, route: Route) -> &mut Route {
let routes = &mut Arc::make_mut(&mut self.table).routes;
routes.push(route);
routes.last_mut().unwrap()
}
}
fn strip_body(res: Response) -> Response {
let (mut parts, body) = res.into_parts();
if let Some(len) = body.size_hint().exact() {
parts
.headers
.entry(header::CONTENT_LENGTH)
.or_insert(HeaderValue::from(len));
}
Response::from_parts(parts, Body::empty())
}
fn is_fresh(
if_none_match: &Option<HeaderValue>,
if_modified_since: &Option<HeaderValue>,
res: &Response,
) -> bool {
if let Some(if_none_match) = if_none_match {
let Some(etag) = res
.headers()
.get(header::ETAG)
.and_then(|v| v.to_str().ok())
else {
return false;
};
let etag = etag.trim_start_matches("W/");
return if_none_match.to_str().is_ok_and(|list| {
list.split(',')
.map(|tag| tag.trim())
.any(|tag| tag == "*" || tag.trim_start_matches("W/") == etag)
});
}
let parse = |v: &HeaderValue| httpdate::parse_http_date(v.to_str().ok()?).ok();
match (
if_modified_since.as_ref().and_then(parse),
res.headers().get(header::LAST_MODIFIED).and_then(parse),
) {
(Some(since), Some(modified)) => modified <= since,
_ => false,
}
}
async fn serve_range(res: &mut Response, range: &HeaderValue, if_range: Option<&HeaderValue>) {
if res.status() != StatusCode::OK {
return;
}
let Some(source) = res.extensions().get::<RangeSource>().cloned() else {
return;
};
let unchanged = res.headers().get(header::CONTENT_LENGTH)
== Some(&HeaderValue::from(source.len))
&& !res.headers().contains_key(header::CONTENT_ENCODING);
if !unchanged {
return;
}
if let Some(if_range) = if_range.and_then(|v| v.to_str().ok()) {
let validator = if if_range.starts_with('"') {
header::ETAG
} else {
header::LAST_MODIFIED
};
if res.headers().get(validator).and_then(|v| v.to_str().ok()) != Some(if_range) {
return;
}
}
let Some(parsed) = range.to_str().ok().and_then(|r| parse_range(r, source.len)) else {
return;
};
match parsed {
Ok((first, last)) => {
let len = last - first + 1;
let Some(body) = source.body(first, len).await else {
return;
};
*res.status_mut() = StatusCode::PARTIAL_CONTENT;
*res.body_mut() = body;
let content_range = format!("bytes {first}-{last}/{}", source.len);
let headers = res.headers_mut();
headers.insert(
header::CONTENT_RANGE,
HeaderValue::try_from(content_range).unwrap(),
);
headers.insert(header::CONTENT_LENGTH, HeaderValue::from(len));
}
Err(()) => {
*res.status_mut() = StatusCode::RANGE_NOT_SATISFIABLE;
*res.body_mut() = Body::empty();
let content_range = format!("bytes */{}", source.len);
let headers = res.headers_mut();
headers.insert(
header::CONTENT_RANGE,
HeaderValue::try_from(content_range).unwrap(),
);
headers.insert(header::CONTENT_LENGTH, HeaderValue::from(0));
headers.remove(header::CONTENT_TYPE);
}
}
}
fn add_etag(res: &mut Response) {
use std::hash::{Hash, Hasher};
if res.headers().contains_key(header::ETAG) {
return;
}
let Some(bytes) = res.body().as_bytes() else {
return;
};
let mut hasher = std::hash::DefaultHasher::new();
bytes.hash(&mut hasher);
let etag = format!("W/\"{:x}-{:x}\"", bytes.len(), hasher.finish());
res.headers_mut().insert(
header::ETAG,
HeaderValue::try_from(etag).expect("hex is valid"),
);
}
fn not_modified(res: &mut Response) {
*res.status_mut() = StatusCode::NOT_MODIFIED;
*res.body_mut() = Body::empty();
let headers = res.headers_mut();
headers.remove(header::CONTENT_TYPE);
headers.remove(header::CONTENT_LENGTH);
}