use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use futures_util::StreamExt;
use indexmap::IndexMap;
use moka::future::Cache;
use crate::bogon::{bogon_lookup, is_bogon};
use crate::database::DatabaseApi;
use crate::entitlement::Entitlement;
use crate::error::{Error, ErrorKind};
use crate::lookup::Lookup;
use crate::models::{BatchLookupRequest, BatchLookupResponse, LookupResponse};
use crate::oauth::{OauthApi, OauthError};
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_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 BATCH_MAX: usize = 1000;
#[derive(Debug, Clone)]
pub struct Client(Arc<Inner>);
#[derive(Debug)]
struct Inner {
transport: Transport,
cache: Option<Cache<String, Lookup>>,
concurrency: usize,
retries: u32,
timeout: Duration,
}
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 timeout = opts.timeout.unwrap_or(self.0.timeout);
let answer: LookupResponse = with_retry(opts.retries.unwrap_or(self.0.retries), || {
self.0.transport.get_json(&path, &[], timeout)
})
.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 timeout = opts.timeout.unwrap_or(self.0.timeout);
let answer: LookupResponse = with_retry(opts.retries.unwrap_or(self.0.retries), || {
self.0.transport.get_json("/myip", &[], timeout)
})
.await?;
Ok(Lookup::served(answer))
}
pub async fn my_entitlement(&self) -> Result<Entitlement, Error> {
self.my_entitlement_with(LookupOptions::new()).await
}
pub async fn my_entitlement_with(&self, opts: LookupOptions) -> Result<Entitlement, Error> {
let timeout = opts.timeout.unwrap_or(self.0.timeout);
with_retry(opts.retries.unwrap_or(self.0.retries), || {
self.0.transport.get_json("/api/v1/entitlement", &[], timeout)
})
.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 retries = opts.retries.unwrap_or(self.0.retries);
let concurrency = opts.concurrency.unwrap_or(self.0.concurrency);
let timeout = opts.timeout.unwrap_or(self.0.timeout);
if concurrency == 0 {
let refused = || Error::Config("concurrency must be at least 1".to_owned());
return unique.into_iter().map(|ip| (ip, Err(refused()))).collect();
}
let mut answers: HashMap<String, Result<Lookup, Error>> =
HashMap::with_capacity(unique.len());
let mut pending: Vec<String> = Vec::new();
for ip in &unique {
if is_bogon(ip) {
answers.insert(ip.clone(), Ok(bogon_lookup(ip)));
continue;
}
if let Some(cache) = &self.0.cache {
if let Some(hit) = cache.get(ip).await {
answers.insert(ip.clone(), Ok(hit));
continue;
}
}
pending.push(ip.clone());
}
let chunks: Vec<Vec<String>> = pending.chunks(BATCH_MAX).map(<[String]>::to_vec).collect();
{
let mut stream = futures_util::stream::iter(chunks)
.map(|chunk| async move { self.lookup_chunk(chunk, retries, timeout).await })
.buffer_unordered(concurrency);
while let Some(chunk_answers) = stream.next().await {
answers.extend(chunk_answers);
}
}
unique
.into_iter()
.map(|ip| {
let answer = answers.remove(&ip).expect("every address is answered exactly once");
(ip, answer)
})
.collect()
}
async fn lookup_chunk(
&self,
chunk: Vec<String>,
retries: u32,
timeout: Duration,
) -> Vec<(String, Result<Lookup, Error>)> {
let request = BatchLookupRequest { ips: chunk.clone() };
let answered: Result<BatchLookupResponse, Error> =
with_retry(retries, || self.0.transport.post_json("/batch", &request, timeout)).await;
let mut body = match answered {
Ok(body) => body,
Err(err) => return chunk.into_iter().map(|ip| (ip, Err(err.restated()))).collect(),
};
let mut out = Vec::with_capacity(chunk.len());
for ip in chunk {
let answer = if let Some(served) = body.results.remove(&ip) {
let lookup = Lookup::served(served);
if let Some(cache) = &self.0.cache {
cache.insert(ip.clone(), lookup.clone()).await;
}
Ok(lookup)
} else if let Some(failed) = body.errors.remove(&ip) {
Err(Error::from_entry(u16::try_from(failed.status).unwrap_or(500), &failed.error))
} else {
Err(Error::Api {
kind: ErrorKind::ServerError,
message: format!("the batch answer did not include {ip}"),
status: 200,
retry_after: None,
})
};
out.push((ip, answer));
}
out
}
pub fn is_bogon(&self, ip: &str) -> bool {
is_bogon(ip)
}
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
}
}
#[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>,
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 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 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 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 timeout = self.timeout.unwrap_or(DEFAULT_TIMEOUT);
if timeout.is_zero() {
return Err(Error::Config("timeout 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),
timeout,
})))
}
}
#[derive(Debug, Clone, Default)]
pub struct LookupOptions {
retries: Option<u32>,
timeout: Option<Duration>,
}
impl LookupOptions {
pub fn new() -> Self {
Self::default()
}
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
}
}
#[derive(Debug, Clone, Default)]
pub struct BatchOptions {
retries: Option<u32>,
concurrency: Option<usize>,
timeout: Option<Duration>,
}
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);
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
}
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) => {
tokio::time::sleep(err.retry_after().unwrap_or(delay)).await;
delay *= 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)
}
}
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()
}