use std::sync::Arc;
use std::time::Duration;
use futures_util::StreamExt;
use indexmap::IndexMap;
use moka::future::Cache;
use crate::account::Account;
use crate::bogon::{bogon_lookup, is_bogon};
use crate::database::DatabaseApi;
use crate::error::Error;
use crate::lookup::Lookup;
use crate::models::LookupResponse;
use crate::transport::{Transport, encode_path_segment};
pub const DEFAULT_BASE_URL: &str = "https://api.vpndetection.io";
const DEFAULT_CACHE_CAPACITY: u64 = 10_000;
const DEFAULT_CACHE_TTL: Duration = Duration::from_secs(60 * 60);
const DEFAULT_CONCURRENCY: usize = 8;
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,
cache: Option<Cache<String, Lookup>>,
concurrency: usize,
retries: u32,
}
impl Client {
pub fn new() -> Result<Self, Error> {
Self::builder().build()
}
pub fn builder() -> ClientBuilder {
ClientBuilder::default()
}
pub async fn lookup(&self, ip: &str) -> Result<Lookup, Error> {
self.lookup_with(ip, LookupOptions::new()).await
}
pub async fn lookup_with(&self, ip: &str, opts: LookupOptions) -> Result<Lookup, Error> {
if is_bogon(ip) {
return Ok(bogon_lookup(ip));
}
if let Some(cache) = &self.0.cache {
if let Some(hit) = cache.get(ip).await {
return Ok(hit);
}
}
let path = format!("/{}", encode_path_segment(ip));
let answer: LookupResponse = with_retry(opts.retries.unwrap_or(self.0.retries), || {
self.0.transport.get_json(&path, &[])
})
.await?;
let lookup = Lookup::served(answer);
if let Some(cache) = &self.0.cache {
cache.insert(ip.to_owned(), lookup.clone()).await;
}
Ok(lookup)
}
pub async fn my_ip(&self) -> Result<Lookup, Error> {
self.my_ip_with(LookupOptions::new()).await
}
pub async fn my_ip_with(&self, opts: LookupOptions) -> Result<Lookup, Error> {
let answer: LookupResponse = with_retry(opts.retries.unwrap_or(self.0.retries), || {
self.0.transport.get_json("/myip", &[])
})
.await?;
Ok(Lookup::served(answer))
}
pub async fn my_account(&self) -> Result<Account, Error> {
self.my_account_with(LookupOptions::new()).await
}
pub async fn my_account_with(&self, opts: LookupOptions) -> Result<Account, Error> {
with_retry(opts.retries.unwrap_or(self.0.retries), || {
self.0.transport.get_json("/api/v1/account/me", &[])
})
.await
}
pub async fn lookup_batch<I, S>(
&self,
ips: I,
opts: BatchOptions,
) -> IndexMap<String, Result<Lookup, Error>>
where
I: IntoIterator<Item = S>,
S: AsRef<str>,
{
let unique = dedupe(ips);
let lookup_opts = LookupOptions { retries: opts.retries };
let concurrency = opts.concurrency.unwrap_or(self.0.concurrency);
let mut answers: Vec<Option<Result<Lookup, Error>>> =
(0..unique.len()).map(|_| None).collect();
{
let mut stream = futures_util::stream::iter(unique.iter().enumerate())
.map(|(i, ip)| {
let opts = lookup_opts.clone();
async move { (i, self.lookup_with(ip, opts).await) }
})
.buffer_unordered(concurrency);
while let Some((i, answer)) = stream.next().await {
answers[i] = Some(answer);
}
}
unique
.into_iter()
.zip(answers)
.map(|(ip, answer)| (ip, answer.expect("every address is answered exactly once")))
.collect()
}
pub fn is_bogon(&self, ip: &str) -> bool {
is_bogon(ip)
}
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>,
cache_capacity: Option<u64>,
cache_ttl: Option<Duration>,
cache_off: bool,
concurrency: Option<usize>,
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 cache(mut self, capacity: u64, ttl: Duration) -> Self {
self.cache_capacity = Some(capacity);
self.cache_ttl = Some(ttl);
self.cache_off = false;
self
}
pub fn no_cache(mut self) -> Self {
self.cache_off = true;
self
}
pub fn concurrency(mut self, n: usize) -> Self {
self.concurrency = Some(n);
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 concurrency = self.concurrency.unwrap_or(DEFAULT_CONCURRENCY);
if concurrency == 0 {
return Err(Error::Config("concurrency must be at least 1".to_owned()));
}
let capacity = self.cache_capacity.unwrap_or(DEFAULT_CACHE_CAPACITY);
let ttl = self.cache_ttl.unwrap_or(DEFAULT_CACHE_TTL);
if capacity == 0 {
return Err(Error::Config("cache capacity must be at least 1".to_owned()));
}
if ttl.is_zero() {
return Err(Error::Config("cache ttl must be positive".to_owned()));
}
let http = match self.http_client {
Some(client) => client,
None => reqwest::Client::builder()
.connect_timeout(DEFAULT_CONNECT_TIMEOUT)
.read_timeout(DEFAULT_READ_TIMEOUT)
.user_agent(concat!("vpndetection-rust/", env!("CARGO_PKG_VERSION")))
.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,
),
cache: (!self.cache_off)
.then(|| Cache::builder().max_capacity(capacity).time_to_live(ttl).build()),
concurrency,
retries: self.retries.unwrap_or(DEFAULT_RETRIES),
})))
}
}
#[derive(Debug, Clone, Default)]
pub struct LookupOptions {
retries: Option<u32>,
}
impl LookupOptions {
pub fn new() -> Self {
Self::default()
}
pub fn retries(mut self, n: u32) -> Self {
self.retries = Some(n);
self
}
}
#[derive(Debug, Clone, Default)]
pub struct BatchOptions {
retries: Option<u32>,
concurrency: Option<usize>,
}
impl BatchOptions {
pub fn new() -> Self {
Self::default()
}
pub fn retries(mut self, n: u32) -> Self {
self.retries = Some(n);
self
}
pub fn concurrency(mut self, n: usize) -> Self {
self.concurrency = Some(n.max(1));
self
}
}
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;
}
}
}
}
fn dedupe<I, S>(ips: I) -> Vec<String>
where
I: IntoIterator<Item = S>,
S: AsRef<str>,
{
let mut seen = std::collections::HashSet::new();
ips.into_iter().map(|ip| ip.as_ref().to_owned()).filter(|ip| seen.insert(ip.clone())).collect()
}