use std::net::SocketAddr;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio::sync::mpsc;
pub(crate) enum HttpReply {
Status(u16),
Raw(String),
Hang,
}
const REQUEST_HEAD_CAP: usize = 8 * 1024;
const REQUEST_DEADLINE: Duration = Duration::from_secs(5);
pub(crate) struct LoopbackHttp {
pub(crate) addr: SocketAddr,
requests: mpsc::UnboundedReceiver<String>,
replies_tx: mpsc::UnboundedSender<HttpReply>,
accept_loop: tokio::task::JoinHandle<()>,
}
impl LoopbackHttp {
pub(crate) async fn next_request(&mut self) -> String {
tokio::time::timeout(REQUEST_DEADLINE, self.requests.recv())
.await
.expect("the fake received no request within the deadline")
.expect("the fake's accept loop ended without sending a request")
}
pub(crate) fn queue_reply(&self, reply: HttpReply) {
self.replies_tx
.send(reply)
.expect("the fake's accept loop had already ended");
}
}
impl Drop for LoopbackHttp {
fn drop(&mut self) {
self.accept_loop.abort();
}
}
pub(crate) async fn loopback_http(script: Vec<HttpReply>) -> LoopbackHttp {
loopback_http_on("127.0.0.1:0", script).await
}
pub(crate) async fn loopback_http_on(bind: &str, script: Vec<HttpReply>) -> LoopbackHttp {
let listener = TcpListener::bind(bind)
.await
.unwrap_or_else(|err| panic!("bind loopback HTTP fake on {bind}: {err}"));
let addr = listener.local_addr().expect("read bound loopback address");
let (requests_tx, requests) = mpsc::unbounded_channel();
let (replies_tx, mut replies_rx) = mpsc::unbounded_channel();
for reply in script {
replies_tx.send(reply).expect("fresh reply receiver");
}
let accept_loop = tokio::spawn(async move {
loop {
let Ok((mut stream, _peer)) = listener.accept().await else {
return; };
if requests_tx
.send(read_request_head(&mut stream).await)
.is_err()
{
return; }
let Some(reply) = replies_rx.recv().await else {
return; };
match reply {
HttpReply::Status(code) => {
let response = format!("HTTP/1.1 {code} OK\r\n\r\n");
let _ = stream.write_all(response.as_bytes()).await;
}
HttpReply::Raw(raw) => {
let _ = stream.write_all(raw.as_bytes()).await;
}
HttpReply::Hang => {
std::future::pending::<()>().await;
}
}
}
});
LoopbackHttp {
addr,
requests,
replies_tx,
accept_loop,
}
}
async fn read_request_head(stream: &mut tokio::net::TcpStream) -> String {
let mut head = Vec::new();
let mut chunk = [0_u8; 256];
while !head.ends_with(b"\r\n\r\n") && head.len() < REQUEST_HEAD_CAP {
match stream.read(&mut chunk).await {
Ok(0) | Err(_) => break,
Ok(n) => head.extend_from_slice(&chunk[..n]),
}
}
String::from_utf8_lossy(&head).into_owned()
}