use std::fmt;
use std::future::Future;
use std::pin::Pin;
use http::{HeaderMap, Method};
use crate::error::TransportError;
pub(crate) const BODY_LIMIT: usize = 64 * 1024 * 1024;
pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
pub trait Transport: Send + Sync + fmt::Debug {
fn send(&self, request: HttpRequest) -> BoxFuture<'_, Result<HttpResponse, TransportError>>;
}
#[derive(Clone)]
pub struct HttpRequest {
pub method: Method,
pub url: String,
pub headers: HeaderMap,
pub body: Option<Vec<u8>>,
}
#[derive(Clone)]
pub struct HttpResponse {
pub status: u16,
pub headers: HeaderMap,
pub body: Vec<u8>,
}
impl HttpResponse {
#[must_use]
pub fn media_type(&self) -> &str {
self.headers
.get(http::header::CONTENT_TYPE)
.and_then(|value| value.to_str().ok())
.and_then(|value| value.split(';').next())
.map_or("", str::trim)
}
#[must_use]
pub fn header(&self, name: &str) -> Option<&str> {
self.headers.get(name).and_then(|value| value.to_str().ok())
}
}
impl fmt::Debug for HttpRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("HttpRequest")
.field("method", &self.method)
.field("url", &self.url)
.field("headers", &self.headers.keys().collect::<Vec<_>>())
.field("body", &self.body.as_ref().map(Vec::len))
.finish()
}
}
impl fmt::Debug for HttpResponse {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("HttpResponse")
.field("status", &self.status)
.field("headers", &self.headers.keys().collect::<Vec<_>>())
.field("body", &self.body.len())
.finish()
}
}
#[derive(Debug, Clone)]
pub struct ReqwestTransport {
client: reqwest::Client,
limit: usize,
}
impl ReqwestTransport {
pub fn new() -> Result<Self, crate::Error> {
Self::with_limit(BODY_LIMIT)
}
pub(crate) fn with_limit(limit: usize) -> Result<Self, crate::Error> {
reqwest::Client::builder()
.redirect(reqwest::redirect::Policy::none())
.build()
.map(|client| ReqwestTransport { client, limit })
.map_err(build_failed)
}
async fn exchange(&self, request: HttpRequest) -> Result<HttpResponse, TransportError> {
let mut builder = self
.client
.request(request.method, request.url)
.headers(request.headers);
if let Some(body) = request.body {
builder = builder.body(body);
}
let mut response = builder.send().await.map_err(failure)?;
let status = response.status().as_u16();
let headers = std::mem::take(response.headers_mut());
let mut body = Vec::new();
while let Some(chunk) = response.chunk().await.map_err(failure)? {
if body.len() + chunk.len() > self.limit {
return Err(TransportError::new(
"response body over the size limit",
false,
));
}
body.extend_from_slice(&chunk);
}
Ok(HttpResponse {
status,
headers,
body,
})
}
}
impl Transport for ReqwestTransport {
fn send(&self, request: HttpRequest) -> BoxFuture<'_, Result<HttpResponse, TransportError>> {
Box::pin(self.exchange(request))
}
}
pub(crate) fn build_failed(_: reqwest::Error) -> crate::Error {
crate::Error::Config("the HTTP client could not be built")
}
fn failure(error: reqwest::Error) -> TransportError {
let timed_out = error.is_timeout();
TransportError::new(error.without_url(), timed_out)
}