use std::time::Duration;
use chrono::TimeZone;
use reqwest::header::{AUTHORIZATION, HeaderMap, RETRY_AFTER};
use serde::de::DeserializeOwned;
use crate::error::{Error, ErrorKind, kind_for_status};
#[derive(Debug, Clone)]
pub(crate) struct Transport {
http: reqwest::Client,
base_url: String,
api_key: Option<String>,
}
impl Transport {
pub(crate) fn new(http: reqwest::Client, base_url: String, api_key: Option<String>) -> Self {
Self { http, base_url, api_key }
}
pub(crate) fn base_url(&self) -> &str {
&self.base_url
}
pub(crate) async fn get_json<T: DeserializeOwned>(
&self,
path: &str,
query: &[(&str, &str)],
timeout: Duration,
) -> Result<T, Error> {
let response = self.send(path, query, timeout).await?;
let status = response.status().as_u16();
let retry_after = parse_retry_after(response.headers());
let body = response.text().await?;
if !(200..300).contains(&status) {
return Err(Error::from_response(status, retry_after, &body));
}
serde_json::from_str(&body).map_err(|e| Error::Api {
kind: ErrorKind::ServerError,
message: format!("could not decode the response: {e}"),
status,
retry_after: None,
})
}
pub(crate) async fn get_redirect(
&self,
path: &str,
query: &[(&str, &str)],
timeout: Duration,
) -> Result<String, Error> {
let response = self.send(path, query, timeout).await?;
let status = response.status().as_u16();
let retry_after = parse_retry_after(response.headers());
let location = response
.headers()
.get(reqwest::header::LOCATION)
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
match (status, location) {
(300..400, Some(location)) => Ok(location),
(300..400, None) => Err(Error::Api {
kind: ErrorKind::ServerError,
message: "the redirect carried no Location header".to_owned(),
status,
retry_after: None,
}),
(200..300, _) if !self.answered_from(path, &response) => Err(Error::Config(
"the download redirect was followed, so its Location is gone: build the \
reqwest::Client you passed to ClientBuilder::http_client with \
reqwest::redirect::Policy::none()"
.to_owned(),
)),
(200..300, _) => Err(Error::Api {
kind: ErrorKind::ServerError,
message: "expected a redirect to object storage".to_owned(),
status,
retry_after: None,
}),
_ => {
let body = response.text().await?;
Err(Error::from_response(status, retry_after, &body))
}
}
}
fn answered_from(&self, path: &str, response: &reqwest::Response) -> bool {
let mut url = response.url().clone();
url.set_query(None);
reqwest::Url::parse(&format!("{}{}", self.base_url, path)).is_ok_and(|sent| sent == url)
}
pub(crate) async fn get_file(&self, url: &str) -> Result<reqwest::Response, Error> {
let response = self.http.get(url).send().await?;
let status = response.status().as_u16();
if (200..300).contains(&status) {
return Ok(response);
}
let retry_after = parse_retry_after(response.headers());
Err(Error::Api {
kind: kind_for_status(status, retry_after),
message: format!("object storage refused the download link with status {status}"),
status,
retry_after,
})
}
pub(crate) async fn get_keyless(&self, path: &str, timeout: Duration) -> Result<Answer, Error> {
let url = format!("{}{}", self.base_url, path);
Answer::read(self.http.get(url).timeout(timeout).send().await?).await
}
pub(crate) async fn post_form(
&self,
path: &str,
form: &[(&str, &str)],
timeout: Duration,
) -> Result<Answer, Error> {
let url = format!("{}{}", self.base_url, path);
Answer::read(self.http.post(url).form(form).timeout(timeout).send().await?).await
}
async fn send(
&self,
path: &str,
query: &[(&str, &str)],
timeout: Duration,
) -> Result<reqwest::Response, Error> {
let url = format!("{}{}", self.base_url, path);
let mut request = self.http.get(url).query(query).timeout(timeout);
if let Some(key) = &self.api_key {
request = request.header(AUTHORIZATION, format!("Bearer {key}"));
}
Ok(request.send().await?)
}
}
pub(crate) struct Answer {
pub(crate) status: u16,
pub(crate) retry_after: Option<Duration>,
pub(crate) body: String,
}
impl Answer {
async fn read(response: reqwest::Response) -> Result<Self, Error> {
let status = response.status().as_u16();
let retry_after = parse_retry_after(response.headers());
Ok(Self { status, retry_after, body: response.text().await? })
}
}
fn parse_retry_after(headers: &HeaderMap) -> Option<Duration> {
let value = headers.get(RETRY_AFTER)?.to_str().ok()?.trim().to_owned();
if value.bytes().all(|b| b.is_ascii_digit()) {
return value.parse::<u64>().ok().map(Duration::from_secs);
}
let wait = http_date(&value)? - chrono::Utc::now().timestamp();
Some(Duration::from_secs(wait.max(0) as u64))
}
fn http_date(value: &str) -> Option<i64> {
if let Ok(when) = chrono::DateTime::parse_from_rfc2822(value) {
return Some(when.timestamp());
}
["%A, %d-%b-%y %H:%M:%S GMT", "%a %b %e %H:%M:%S %Y"]
.into_iter()
.find_map(|format| chrono::NaiveDateTime::parse_from_str(value, format).ok())
.map(|when| chrono::Utc.from_utc_datetime(&when).timestamp())
}
#[cfg(test)]
mod tests {
use super::http_date;
#[test]
fn an_http_date_is_read_in_all_three_forms() {
for value in [
"Sun, 06 Nov 1994 08:49:37 GMT",
"Sunday, 06-Nov-94 08:49:37 GMT",
"Sun Nov 6 08:49:37 1994",
] {
assert_eq!(http_date(value), Some(784_111_777), "{value}");
}
}
#[test]
fn nothing_else_is_an_http_date() {
for value in ["-1", "x", "tomorrow", "noon", "+1 day", "1e400", "soon", "1994-11-06"] {
assert_eq!(http_date(value), None, "{value}");
}
}
}