use std::sync::Arc;
use std::time::Duration;
use crate::database::DatabaseApi;
use crate::error::Error;
use crate::transport::Transport;
pub const DEFAULT_BASE_URL: &str = "https://internetdata.io";
const DEFAULT_RETRIES: u32 = 2;
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);
#[derive(Debug, Clone)]
pub struct Client(Arc<Inner>);
#[derive(Debug)]
struct Inner {
transport: Transport,
retries: u32,
}
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(crate) fn transport(&self) -> &Transport {
&self.0.transport
}
pub(crate) fn retries(&self) -> u32 {
self.0.retries
}
}
#[derive(Debug, Default)]
pub struct ClientBuilder {
api_key: Option<String>,
base_url: Option<String>,
retries: Option<u32>,
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 http_client(mut self, client: reqwest::Client) -> Self {
self.http_client = Some(client);
self
}
pub fn build(self) -> Result<Client, Error> {
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 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(),
self.api_key.filter(|key| !key.is_empty()),
),
retries: self.retries.unwrap_or(DEFAULT_RETRIES),
})))
}
}
pub(crate) async fn with_retry<T, F, Fut>(retries: u32, mut attempt: F) -> Result<T, Error>
where
F: FnMut() -> Fut,
Fut: Future<Output = Result<T, Error>>,
{
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) => {
tokio::time::sleep(err.retry_after().unwrap_or(delay)).await;
delay *= 2;
remaining -= 1;
}
}
}
}