use std::time::Duration;
use serde_json::Value;
use crate::client::Client;
use crate::encoding::{encode_query, resolve_path};
use crate::endpoints::Method;
use crate::error::{ApiError, Error, Result, parse_error_message, reason_phrase};
use crate::options::RequestConfig;
use crate::response::Response;
const TRANSIENT_BODY_MARKERS: [&str; 3] = [
"something bad has happened",
"something went wrong while fetching from ldfeaturecontaineradaptor",
"timeout",
];
const MAX_RETRY_AFTER_SECS: f64 = 300.0;
pub(crate) fn is_transient(status: u16, message: &str) -> bool {
if matches!(status, 408 | 500 | 502 | 503 | 504) {
return true;
}
if status == 400 {
let lower = message.to_lowercase();
return TRANSIENT_BODY_MARKERS.iter().any(|m| lower.contains(m));
}
false
}
fn set_header<T>(
r: &mut ureq::RequestBuilder<T>,
name: &str,
value: &str,
) -> std::result::Result<(), ureq::Error> {
let Some(map) = r.headers_mut() else {
return Ok(());
};
let name = ureq::http::HeaderName::try_from(name).map_err(ureq::http::Error::from)?;
let value = ureq::http::HeaderValue::try_from(value).map_err(ureq::http::Error::from)?;
map.insert(name, value);
Ok(())
}
fn apply_headers<T>(
mut r: ureq::RequestBuilder<T>,
client: &Client,
cfg: &RequestConfig<'_>,
) -> std::result::Result<ureq::RequestBuilder<T>, ureq::Error> {
for (k, v) in &client.inner.headers {
r = r.header(k, v);
}
for (k, v) in &cfg.headers {
set_header(&mut r, k, v)?;
}
set_header(&mut r, "User-Agent", &client.inner.user_agent)?;
set_header(&mut r, "Content-Type", cfg.content_type)?;
set_header(&mut r, "Accept", cfg.content_type)?;
Ok(r)
}
impl Client {
fn send_once(
&self,
method: Method,
url: &str,
cfg: &RequestConfig<'_>,
body: Option<&[u8]>,
) -> std::result::Result<ureq::http::Response<ureq::Body>, ureq::Error> {
match method {
Method::Get => apply_headers(self.inner.agent.get(url), self, cfg)?.call(),
Method::Post => {
apply_headers(self.inner.agent.post(url), self, cfg)?.send(body.unwrap_or(&[]))
}
}
}
fn backoff(&self, attempt: u32, retry_after: Option<f64>) -> Duration {
if let Some(retry_after) = retry_after
&& retry_after > 0.0
{
return Duration::from_secs_f64(retry_after.min(MAX_RETRY_AFTER_SECS));
}
self.inner
.wall_time
.saturating_mul(2)
.saturating_mul(attempt)
.max(Duration::from_millis(10))
}
pub(crate) fn execute(
&self,
method: Method,
path_template: &str,
path_params: &[(&str, &str)],
body: Option<&Value>,
cfg: &RequestConfig<'_>,
) -> Result<Response> {
let path = resolve_path(path_template, path_params)?;
let mut url = format!("{}{}", self.inner.base_url, path);
let query = encode_query(&cfg.query);
if !query.is_empty() {
url.push('?');
url.push_str(&query);
}
let body_bytes: Option<Vec<u8>> = match body {
Some(v) => Some(serde_json::to_vec(v).map_err(Error::Decode)?),
None => None,
};
let mut last: Option<Error> = None;
for attempt in 1..=self.inner.max_attempts {
self.inner.limiter.wait();
let sticky_retry_after = match self.send_once(method, &url, cfg, body_bytes.as_deref())
{
Ok(mut raw) => {
let status = raw.status().as_u16();
let rate_limit = crate::ratelimit::parse_headers(raw.headers());
let merged = self.inner.limiter.merge(&rate_limit);
let content_type = raw
.headers()
.get("Content-Type")
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
let bytes = raw
.body_mut()
.with_config()
.limit(self.inner.max_response_bytes)
.read_to_vec()
.map_err(|e| Error::Transport(Box::new(e)))?;
if (200..300).contains(&status) {
return Ok(Response::new(status, content_type, rate_limit, bytes));
}
let message = parse_error_message(&bytes, reason_phrase(status));
let api = ApiError {
status,
message,
rate_limit,
body: bytes,
};
if !is_transient(api.status, &api.message) && api.status != 429 {
return Err(Error::Api(api));
}
last = Some(Error::Api(api));
merged.retry_after
}
Err(e) => {
last = Some(Error::Transport(Box::new(e)));
None
}
};
if attempt < self.inner.max_attempts {
std::thread::sleep(self.backoff(attempt, sticky_retry_after));
}
}
Err(Error::MaxRetries {
attempts: self.inner.max_attempts,
last: Box::new(last.expect("at least one attempt was made")),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn server_side_statuses_are_always_transient() {
for status in [408, 500, 502, 503, 504] {
assert!(is_transient(status, ""), "{status} should be transient");
}
}
#[test]
fn client_side_statuses_are_not_transient() {
for status in [400, 401, 403, 404, 415] {
assert!(
!is_transient(status, "ordinary message"),
"{status} should be fatal"
);
}
}
#[test]
fn a_400_is_transient_only_for_known_ensembl_messages() {
assert!(is_transient(400, "Something bad has happened"));
assert!(is_transient(
400,
"Something went wrong while fetching from LDFeatureContainerAdaptor"
));
assert!(is_transient(400, "Request timeout while processing"));
assert!(!is_transient(400, "ID 'NOPE' not found"));
}
#[test]
fn backoff_clamps_a_garbled_retry_after_instead_of_panicking() {
let c = Client::new().unwrap();
for raw in [
f64::INFINITY,
"1e400".parse::<f64>().unwrap(),
f64::MAX,
1e30,
] {
assert_eq!(
c.backoff(1, Some(raw)),
Duration::from_secs_f64(MAX_RETRY_AFTER_SECS),
"Retry-After {raw} must clamp, not panic or sleep for ever"
);
}
}
#[test]
fn backoff_honours_a_sane_retry_after_unchanged() {
let c = Client::new().unwrap();
assert_eq!(c.backoff(1, Some(2.5)), Duration::from_secs_f64(2.5));
assert_eq!(
c.backoff(1, None),
Duration::from_secs(2),
"with no Retry-After, backoff is attempt * wall_time * 2"
);
}
#[test]
fn transient_message_matching_ignores_case() {
assert!(is_transient(400, "SOMETHING BAD HAS HAPPENED"));
assert!(is_transient(400, "something bad has happened"));
}
}