use std::collections::HashMap;
use std::fmt;
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::time::Duration;
use crate::error::{Error, Result};
pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
#[derive(Clone, Debug)]
pub struct HttpRequest {
pub method: String,
pub url: String,
pub headers: Vec<(String, String)>,
pub body: Option<Vec<u8>>,
}
#[derive(Clone, Debug)]
pub struct HttpResponse {
pub status: u16,
pub headers: HashMap<String, String>,
pub body: String,
}
impl HttpResponse {
pub fn header(&self, name: &str) -> Option<&str> {
self.headers
.get(&name.to_ascii_lowercase())
.map(String::as_str)
}
}
pub trait Transport: Send + Sync + fmt::Debug {
fn execute<'a>(&'a self, request: HttpRequest) -> BoxFuture<'a, Result<HttpResponse>>;
}
impl<T: Transport + ?Sized> Transport for Arc<T> {
fn execute<'a>(&'a self, request: HttpRequest) -> BoxFuture<'a, Result<HttpResponse>> {
(**self).execute(request)
}
}
const REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
#[derive(Clone, Debug)]
pub struct ReqwestTransport {
client: reqwest::Client,
}
impl ReqwestTransport {
pub fn new() -> Self {
Self::with_client(
reqwest::Client::builder()
.timeout(REQUEST_TIMEOUT)
.build()
.expect("could not build the HTTP client"),
)
}
pub fn with_client(client: reqwest::Client) -> Self {
Self { client }
}
}
impl Default for ReqwestTransport {
fn default() -> Self {
Self::new()
}
}
impl Transport for ReqwestTransport {
fn execute<'a>(&'a self, request: HttpRequest) -> BoxFuture<'a, Result<HttpResponse>> {
Box::pin(async move {
let method =
reqwest::Method::from_bytes(request.method.as_bytes()).map_err(|error| {
Error::client(
format!("invalid HTTP method {:?}", request.method),
"invalid_request",
)
.with_source(error)
})?;
let mut builder = self.client.request(method, &request.url);
for (name, value) in &request.headers {
builder = builder.header(name, value);
}
if let Some(body) = request.body {
builder = builder.body(body);
}
let response = builder.send().await.map_err(|error| {
Error::client(
format!("could not reach the Mailtea API: {error}"),
"transport_error",
)
.with_source(error)
})?;
let status = response.status().as_u16();
let headers = response
.headers()
.iter()
.map(|(name, value)| {
(
name.as_str().to_ascii_lowercase(),
value.to_str().unwrap_or_default().to_string(),
)
})
.collect();
let body = response.text().await.map_err(|error| {
Error::client(
format!("could not read the Mailtea API response: {error}"),
"transport_error",
)
.with_source(error)
})?;
Ok(HttpResponse {
status,
headers,
body,
})
})
}
}