use std::sync::Arc;
use std::time::Duration;
use crate::database::DatabaseApi;
use crate::error::Error;
use crate::oauth::{OauthApi, OauthError};
use crate::transport::Transport;
pub const DEFAULT_BASE_URL: &str = "https://internetdata.io";
const DEFAULT_RETRIES: u32 = 2;
const DEFAULT_TIMEOUT: Duration = Duration::from_secs(30);
const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(30);
const RETRY_BASE_DELAY: Duration = Duration::from_millis(250);
const MAX_RETRY_AFTER: Duration = Duration::from_millis(2_147_483_647);
#[derive(Debug, Clone)]
pub struct Client(Arc<Inner>);
#[derive(Debug)]
struct Inner {
transport: Transport,
retries: u32,
timeout: Duration,
}
impl Client {
pub fn new() -> Result<Self, Error> {
Self::builder().build()
}
pub fn builder() -> ClientBuilder {
ClientBuilder::default()
}
pub fn database(&self) -> DatabaseApi<'_> {
DatabaseApi::new(self)
}
pub fn oauth(&self) -> OauthApi<'_> {
OauthApi::new(self)
}
pub(crate) fn transport(&self) -> &Transport {
&self.0.transport
}
pub(crate) fn retries(&self) -> u32 {
self.0.retries
}
pub(crate) fn timeout(&self) -> Duration {
self.0.timeout
}
pub(crate) fn call_timeout(&self, per_call: Option<Duration>) -> Result<Duration, Error> {
match per_call {
Some(timeout) if timeout.is_zero() => {
Err(Error::Config("timeout must be positive".to_owned()))
}
Some(timeout) => Ok(timeout),
None => Ok(self.0.timeout),
}
}
}
#[derive(Debug, Default)]
pub struct ClientBuilder {
api_key: Option<String>,
base_url: Option<String>,
retries: Option<u32>,
timeout: Option<Duration>,
http_client: Option<reqwest::Client>,
}
impl ClientBuilder {
pub fn new() -> Self {
Self::default()
}
pub fn api_key(mut self, key: impl Into<String>) -> Self {
self.api_key = Some(key.into());
self
}
pub fn base_url(mut self, url: impl Into<String>) -> Self {
self.base_url = Some(url.into());
self
}
pub fn retries(mut self, n: u32) -> Self {
self.retries = Some(n);
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
pub fn http_client(mut self, client: reqwest::Client) -> Self {
self.http_client = Some(client);
self
}
pub fn build(self) -> Result<Client, Error> {
let timeout = self.timeout.unwrap_or(DEFAULT_TIMEOUT);
if timeout.is_zero() {
return Err(Error::Config("timeout must be positive".to_owned()));
}
let base_url = self.base_url.unwrap_or_else(|| DEFAULT_BASE_URL.to_owned());
let parsed = reqwest::Url::parse(&base_url)
.map_err(|e| Error::Config(format!("base url {base_url:?}: {e}")))?;
if !parsed.has_host() {
return Err(Error::Config(format!("base url {base_url:?} needs a scheme and a host")));
}
let api_key = self.api_key.map(|key| key.trim().to_owned()).filter(|key| !key.is_empty());
if api_key.as_deref().is_some_and(|key| key.chars().any(char::is_control)) {
return Err(Error::Config("the API key holds a control character".to_owned()));
}
let http = match self.http_client {
Some(client) => client,
None => reqwest::Client::builder()
.user_agent(concat!("internetdata-rust/", env!("CARGO_PKG_VERSION")))
.connect_timeout(DEFAULT_CONNECT_TIMEOUT)
.read_timeout(DEFAULT_READ_TIMEOUT)
.redirect(reqwest::redirect::Policy::none())
.build()?,
};
Ok(Client(Arc::new(Inner {
transport: Transport::new(http, base_url.trim_end_matches('/').to_owned(), api_key),
retries: self.retries.unwrap_or(DEFAULT_RETRIES),
timeout,
})))
}
}
pub(crate) async fn with_retry<T, E, F, Fut>(retries: u32, mut attempt: F) -> Result<T, E>
where
E: Retry,
F: FnMut() -> Fut,
Fut: Future<Output = Result<T, E>>,
{
let mut delay = RETRY_BASE_DELAY;
let mut remaining = retries;
loop {
match attempt().await {
Ok(value) => return Ok(value),
Err(err) if remaining == 0 || !err.retryable() => return Err(err),
Err(err) => {
let wait = err.retry_after().filter(|wait| *wait <= MAX_RETRY_AFTER);
tokio::time::sleep(wait.unwrap_or(delay)).await;
delay = delay.saturating_mul(2);
remaining -= 1;
}
}
}
}
pub(crate) trait Retry {
fn retryable(&self) -> bool;
fn retry_after(&self) -> Option<Duration>;
}
impl Retry for Error {
fn retryable(&self) -> bool {
Error::retryable(self)
}
fn retry_after(&self) -> Option<Duration> {
Error::retry_after(self)
}
}
impl Retry for OauthError {
fn retryable(&self) -> bool {
OauthError::retryable(self)
}
fn retry_after(&self) -> Option<Duration> {
OauthError::retry_after(self)
}
}