use std::time::Duration;
use bytes::Bytes;
use tokio::time::Instant;
use crate::error::{Error, truncate};
use crate::http::header::{ACCEPT, CONTENT_TYPE};
use crate::http::{Body, HttpClient, Method, Request, Response, StatusCode};
use crate::security::origin_of;
use url::Url;
pub const DEFAULT_REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
pub const MAX_REQUEST_TIMEOUT: Duration = Duration::from_secs(3600);
pub(super) const MAX_RESPONSE_BYTES: usize = 1_048_576;
pub(super) const FORM_CONTENT_TYPE: &str = "application/x-www-form-urlencoded";
pub(super) fn normalize_timeout(timeout: Duration) -> Duration {
if timeout.is_zero() || timeout > MAX_REQUEST_TIMEOUT {
DEFAULT_REQUEST_TIMEOUT
} else {
timeout
}
}
pub(super) enum TransportFailure {
TimedOut,
Failed(Error),
}
pub(super) enum BodyFailure {
TimedOut,
TooLarge(Error),
Failed(Error),
}
pub(super) async fn send_within(
http: &dyn HttpClient,
deadline: Instant,
request: Request<Bytes>,
) -> Result<Response<Body>, TransportFailure> {
match tokio::time::timeout_at(deadline, http.send(request)).await {
Ok(Ok(response)) => Ok(response),
Ok(Err(error)) if error.is_timeout() => Err(TransportFailure::TimedOut),
Ok(Err(error)) => Err(TransportFailure::Failed(error)),
Err(_) => Err(TransportFailure::TimedOut),
}
}
pub(super) async fn read_within(
deadline: Instant,
body: Body,
status: StatusCode,
) -> Result<Bytes, BodyFailure> {
let read = body.collect(MAX_RESPONSE_BYTES, || {
Error::response_too_large(MAX_RESPONSE_BYTES).with_status(status.as_u16())
});
match tokio::time::timeout_at(deadline, read).await {
Ok(Ok(body)) => Ok(body),
Ok(Err(error)) if error.is_response_too_large() => Err(BodyFailure::TooLarge(error)),
Ok(Err(error)) if error.is_timeout() => Err(BodyFailure::TimedOut),
Ok(Err(error)) => Err(BodyFailure::Failed(error)),
Err(_) => Err(BodyFailure::TimedOut),
}
}
pub(super) fn form_post(url: &Url, form: String) -> Result<Request<Bytes>, Error> {
Request::builder()
.method(Method::POST)
.uri(url.as_str())
.header(ACCEPT, "application/json")
.header(CONTENT_TYPE, FORM_CONTENT_TYPE)
.body(Bytes::from(form))
.map_err(|_| {
Error::usage(format!(
"could not build a request to {}",
origin_of(url.as_str())
))
})
}
pub(super) fn json_get(url: &str) -> Result<Request<Bytes>, Error> {
Request::builder()
.method(Method::GET)
.uri(url)
.header(ACCEPT, "application/json")
.body(Bytes::new())
.map_err(|_| Error::usage(format!("could not build a request to {}", origin_of(url))))
}
pub(super) fn network_failure(url: &Url, failure: &TransportFailure) -> Error {
let error = Error::network_at(&origin_of(url.as_str()));
match failure {
TransportFailure::TimedOut => error.with_hint("the request timed out").timed_out(),
TransportFailure::Failed(_) => error,
}
}
pub(super) fn is_refused_redirect(status: StatusCode) -> bool {
matches!(status.as_u16(), 301 | 302 | 303 | 307 | 308)
}
pub(super) fn oauth_error_fields(body: &[u8]) -> Option<(String, Option<String>)> {
let value: serde_json::Value = serde_json::from_slice(body).ok()?;
let code = value.get("error")?.as_str()?;
if code.is_empty() {
return None;
}
let description = value
.get("error_description")
.and_then(serde_json::Value::as_str)
.filter(|text| !text.is_empty())
.map(truncate);
Some((truncate(code), description))
}