use kernel::Signal;
use std::sync::mpsc;
use std::time::Duration;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HttpRequest {
pub method: String,
pub url: String,
pub headers: Vec<(String, String)>,
pub body: Option<Vec<u8>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct HttpResponse {
pub status: u16,
pub retry_after: Option<String>,
pub body: Vec<u8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransportError {
Timeout,
Aborted,
TooLarge,
Failed,
}
pub trait Transport: Send + Sync {
fn send(
&self,
request: HttpRequest,
max_bytes: usize,
timeout: Duration,
signal: &Signal,
) -> Result<HttpResponse, TransportError>;
}
pub struct ReqwestTransport {
client: reqwest::Client,
runtime: Option<tokio::runtime::Runtime>,
}
impl ReqwestTransport {
pub fn new() -> Result<Self, String> {
let runtime = tokio::runtime::Builder::new_multi_thread()
.worker_threads(1)
.thread_name("blocking-http")
.enable_all()
.build()
.map_err(|e| e.to_string())?;
let client = reqwest::Client::builder()
.no_proxy()
.redirect(reqwest::redirect::Policy::none())
.build()
.map_err(|e| e.to_string())?;
Ok(Self {
client,
runtime: Some(runtime),
})
}
}
impl Drop for ReqwestTransport {
fn drop(&mut self) {
if let Some(runtime) = self.runtime.take() {
runtime.shutdown_background();
}
}
}
fn declared_over(length: &str, max: usize) -> bool {
length.trim().parse::<f64>().is_ok_and(|n| n > max as f64)
}
async fn exchange(
client: reqwest::Client,
request: HttpRequest,
max_bytes: usize,
) -> Result<HttpResponse, TransportError> {
let method = reqwest::Method::from_bytes(request.method.as_bytes()).map_err(|_| TransportError::Failed)?;
let mut builder = client.request(method, &request.url);
for (name, value) in &request.headers {
let bytes: Vec<u8> = value.chars().map(|c| c as u32 as u8).collect();
let value = reqwest::header::HeaderValue::from_bytes(&bytes).map_err(|_| TransportError::Failed)?;
builder = builder.header(name.as_str(), value);
}
if let Some(body) = request.body {
builder = builder.body(body);
}
let mut response = builder.send().await.map_err(|_| TransportError::Failed)?;
let status = response.status().as_u16();
let retry_after = response
.headers()
.get(reqwest::header::RETRY_AFTER)
.map(|value| String::from_utf8_lossy(value.as_bytes()).into_owned());
if !(200..300).contains(&status) {
return Ok(HttpResponse {
status,
retry_after,
body: Vec::new(),
});
}
if let Some(length) = response.headers().get(reqwest::header::CONTENT_LENGTH)
&& declared_over(&String::from_utf8_lossy(length.as_bytes()), max_bytes)
{
return Err(TransportError::TooLarge);
}
let mut body = Vec::new();
while let Some(chunk) = response.chunk().await.map_err(|_| TransportError::Failed)? {
if body.len() + chunk.len() > max_bytes {
return Err(TransportError::TooLarge);
}
body.extend_from_slice(&chunk);
}
Ok(HttpResponse {
status,
retry_after,
body,
})
}
impl Transport for ReqwestTransport {
fn send(
&self,
request: HttpRequest,
max_bytes: usize,
timeout: Duration,
signal: &Signal,
) -> Result<HttpResponse, TransportError> {
let Some(runtime) = &self.runtime else {
return Err(TransportError::Failed);
};
if signal.is_aborted() {
return Err(TransportError::Aborted);
}
let (done, outcome) = mpsc::channel();
let task = runtime.spawn({
let client = self.client.clone();
async move {
let _ = done.send(exchange(client, request, max_bytes).await);
}
});
let abort = task.abort_handle();
let _link = signal.link(move |_| abort.abort());
let result = match outcome.recv_timeout(timeout) {
Ok(result) => result,
Err(mpsc::RecvTimeoutError::Timeout) => Err(TransportError::Timeout),
Err(mpsc::RecvTimeoutError::Disconnected) if signal.is_aborted() => Err(TransportError::Aborted),
Err(mpsc::RecvTimeoutError::Disconnected) => Err(TransportError::Failed),
};
task.abort();
result
}
}