use super::{
metrics::ServerMetrics,
record::{HttpMetadata, HttpRecord},
};
use crate::{
codec::{Codec, Decoder},
shutdown::CancellationToken,
};
use bytes::Bytes;
use http_body_util::{BodyExt, Full, LengthLimitError, Limited};
use hyper::{
Method, Request, Response, StatusCode, body::Incoming, header, server::conn::http1,
service::service_fn,
};
use hyper_util::{rt::TokioIo, server::graceful::GracefulShutdown};
use std::{
convert::Infallible,
net::SocketAddr,
sync::Arc,
time::{Duration, Instant},
};
use tokio::{
net::TcpListener,
sync::{mpsc, oneshot},
};
use tracing::{debug, warn};
const ACCEPT_BACKOFF: Duration = Duration::from_millis(100);
pub(super) struct Pending<T> {
pub raw: HttpRecord<Vec<u8>>,
pub body: T,
pub respond: oneshot::Sender<StatusCode>,
}
pub(super) struct Intake<C: Codec> {
pub requests: mpsc::Sender<Pending<C::Value>>,
pub codec: Arc<C>,
pub max_body_bytes: usize,
pub metrics: Arc<ServerMetrics>,
}
impl<C: Codec> Clone for Intake<C> {
fn clone(&self) -> Self {
Self {
requests: self.requests.clone(),
codec: self.codec.clone(),
max_body_bytes: self.max_body_bytes,
metrics: self.metrics.clone(),
}
}
}
pub(super) async fn serve<C>(listener: TcpListener, intake: Intake<C>, shutdown: CancellationToken)
where
C: Decoder<Value: Send + 'static>,
{
let graceful = GracefulShutdown::new();
loop {
let (stream, remote_addr) = tokio::select! {
biased;
_ = shutdown.cancelled() => break,
accepted = listener.accept() => match accepted {
Ok(accepted) => accepted,
Err(error) => {
warn!(error = %error, "HTTP accept failed");
tokio::time::sleep(ACCEPT_BACKOFF).await;
continue;
}
},
};
let open = intake.metrics.connection();
let intake = intake.clone();
let service = service_fn(move |request| handle(request, remote_addr, intake.clone()));
let connection =
graceful.watch(http1::Builder::new().serve_connection(TokioIo::new(stream), service));
tokio::spawn(async move {
if let Err(error) = connection.await {
debug!(error = %error, "HTTP connection closed with an error");
}
drop(open);
});
}
drop(listener);
graceful.shutdown().await;
}
async fn handle<C: Decoder>(
request: Request<Incoming>,
remote_addr: SocketAddr,
intake: Intake<C>,
) -> Result<Response<Full<Bytes>>, Infallible> {
let started = Instant::now();
let _open = intake.metrics.request();
let response = if request.method() == Method::POST {
deliver(request, remote_addr, &intake).await
} else {
let mut response = status(StatusCode::METHOD_NOT_ALLOWED);
response
.headers_mut()
.insert(header::ALLOW, header::HeaderValue::from_static("POST"));
response
};
intake.metrics.response(response.status(), started);
Ok(response)
}
fn status(status: StatusCode) -> Response<Full<Bytes>> {
let mut response = Response::new(Full::default());
*response.status_mut() = status;
response
}
async fn deliver<C: Decoder>(
request: Request<Incoming>,
remote_addr: SocketAddr,
intake: &Intake<C>,
) -> Response<Full<Bytes>> {
let (parts, body) = request.into_parts();
let body = match Limited::new(body, intake.max_body_bytes).collect().await {
Ok(collected) => {
let body = collected.to_bytes().to_vec();
intake.metrics.body(body.len());
body
}
Err(error) if error.is::<LengthLimitError>() => {
return status(StatusCode::PAYLOAD_TOO_LARGE);
}
Err(_) => return status(StatusCode::BAD_REQUEST),
};
let decoded = match intake.codec.decode(&body) {
Ok(decoded) => decoded,
Err(error) => {
debug!(
error = format!("{error:#}"),
"HTTP request body failed to decode"
);
let mut response = Response::new(Full::from(format!("{error:#}\n")));
*response.status_mut() = StatusCode::BAD_REQUEST;
response.headers_mut().insert(
header::CONTENT_TYPE,
header::HeaderValue::from_static("text/plain; charset=utf-8"),
);
return response;
}
};
let raw = HttpRecord {
path: parts.uri.path().to_owned(),
query: parts.uri.query().map(str::to_owned),
headers: parts
.headers
.iter()
.map(|(name, value)| (name.as_str().to_owned(), value.as_bytes().to_vec()))
.collect(),
body,
metadata: HttpMetadata { remote_addr },
};
let (respond, outcome) = oneshot::channel();
let pending = Pending {
raw,
body: decoded,
respond,
};
if intake.requests.send(pending).await.is_err() {
return status(StatusCode::SERVICE_UNAVAILABLE);
}
status(outcome.await.unwrap_or(StatusCode::SERVICE_UNAVAILABLE))
}