use super::{
config::{ResponseTiming, SourceConfig},
metrics::ServerMetrics,
record::HttpRecord,
server::{Intake, Pending, serve},
};
use crate::{
codec::{Codec, Decoder},
error::{BoxError, Context, Error},
message::SourceMessage,
shutdown::CancellationToken,
source::{Receive, ReceiveError, Source},
};
use hyper::StatusCode;
use std::{
io, mem,
net::{self, SocketAddr},
sync::Arc,
};
use tokio::{
net::TcpListener,
sync::{mpsc, oneshot},
task::JoinHandle,
};
enum State<T> {
Bound(net::TcpListener),
Serving {
requests: mpsc::Receiver<Pending<T>>,
server: JoinHandle<()>,
},
Closed,
}
pub struct HttpSource<C: Codec> {
config: SourceConfig,
codec: Arc<C>,
local_addr: SocketAddr,
state: State<C::Value>,
shutdown: CancellationToken,
}
impl<C: Codec + Default> HttpSource<C> {
pub fn new(bind: SocketAddr) -> Result<Self, Error> {
Self::with_codec(C::default(), bind)
}
}
impl<C: Codec> HttpSource<C> {
pub fn with_codec(codec: C, bind: SocketAddr) -> Result<Self, Error> {
let bind_listener = || -> io::Result<(net::TcpListener, SocketAddr)> {
let listener = net::TcpListener::bind(bind)?;
listener.set_nonblocking(true)?;
let local_addr = listener.local_addr()?;
Ok((listener, local_addr))
};
let (listener, local_addr) =
bind_listener().with_context(|| format!("binding the HTTP source to {bind}"))?;
Ok(Self {
local_addr,
config: SourceConfig::default(),
codec: Arc::new(codec),
state: State::Bound(listener),
shutdown: CancellationToken::new(),
})
}
pub fn max_body_bytes(mut self, max: usize) -> Self {
self.config.max_body_bytes = max;
self
}
pub fn response(mut self, response: ResponseTiming) -> Self {
self.config.response = response;
self
}
pub fn validate(&self) -> Result<(), Error> {
self.config.validate()
}
pub fn local_addr(&self) -> SocketAddr {
self.local_addr
}
}
impl<C> HttpSource<C>
where
C: Decoder<Value: Send + 'static>,
{
fn start(&mut self) -> Result<(), ReceiveError> {
if !matches!(self.state, State::Bound(_)) {
return Ok(());
}
self.validate()
.map_err(|error| ReceiveError::Fatal(error.into()))?;
let State::Bound(listener) = mem::replace(&mut self.state, State::Closed) else {
unreachable!("checked above");
};
let listener =
TcpListener::from_std(listener).map_err(|error| ReceiveError::Fatal(error.into()))?;
let (sender, requests) = mpsc::channel(1);
let intake = Intake {
requests: sender,
codec: self.codec.clone(),
max_body_bytes: self.config.max_body_bytes,
metrics: Arc::new(ServerMetrics::new(self.local_addr)),
};
let server = tokio::spawn(serve(listener, intake, self.shutdown.clone()));
self.state = State::Serving { requests, server };
Ok(())
}
}
impl<C> Source for HttpSource<C>
where
C: Decoder<Value: Clone + Send + Sync + 'static>,
{
type Message = HttpMessage<C::Value>;
async fn receive(&mut self) -> Result<Receive<Self::Message>, ReceiveError> {
self.start()?;
let State::Serving { requests, .. } = &mut self.state else {
return Ok(Receive::End);
};
Ok(match requests.recv().await {
Some(Pending { raw, body, respond }) => Receive::Message(HttpMessage {
raw,
body,
respond: match self.config.response {
ResponseTiming::Ack => Some(respond),
ResponseTiming::Receive => {
let _ = respond.send(StatusCode::ACCEPTED);
None
}
},
}),
None => Receive::End,
})
}
fn stop_receiving(&mut self) {
self.shutdown.cancel();
if let State::Serving { requests, .. } = &mut self.state {
requests.close();
while requests.try_recv().is_ok() {}
}
}
async fn close(&mut self) -> Result<(), BoxError> {
self.shutdown.cancel();
if let State::Serving { requests, server } = mem::replace(&mut self.state, State::Closed) {
drop(requests);
server.await?;
}
Ok(())
}
}
impl<C: Codec> Drop for HttpSource<C> {
fn drop(&mut self) {
self.shutdown.cancel();
}
}
pub struct HttpMessage<T> {
raw: HttpRecord<Vec<u8>>,
body: T,
respond: Option<oneshot::Sender<StatusCode>>,
}
impl<T: Clone + Send + Sync + 'static> SourceMessage for HttpMessage<T> {
type Item = HttpRecord<T>;
type Raw = HttpRecord<Vec<u8>>;
fn decode(&self) -> Result<HttpRecord<T>, BoxError> {
Ok(HttpRecord {
path: self.raw.path.clone(),
query: self.raw.query.clone(),
headers: self.raw.headers.clone(),
body: self.body.clone(),
metadata: self.raw.metadata.clone(),
})
}
async fn ack(self) -> Result<(), BoxError> {
if let Some(respond) = self.respond {
let _ = respond.send(StatusCode::OK);
}
Ok(())
}
fn raw(&self) -> HttpRecord<Vec<u8>> {
self.raw.clone()
}
fn propagation_fields(&self) -> Vec<(&str, &str)> {
self.raw
.headers
.iter()
.filter_map(|(name, value)| Some((name.as_str(), std::str::from_utf8(value).ok()?)))
.collect()
}
}