use async_trait::async_trait;
use bytes::Bytes;
use governor::{Quota, RateLimiter, clock::DefaultClock, state::direct::NotKeyed};
use reqwest::Client;
use reqwest_middleware::{
ClientBuilder, ClientWithMiddleware, Middleware, Next, RequestBuilder,
Result as MiddlewareResult,
};
use reqwest_retry::{DefaultRetryableStrategy, RetryPolicy, RetryableStrategy};
use reqwest_retry::{RetryTransientMiddleware, policies::ExponentialBackoff};
use std::num::NonZeroU32;
use std::path::Path;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Duration;
use tokio::io::AsyncWriteExt;
use crate::error::{MoonError, Result};
use crate::hooks::ClientHook;
use crate::response::FromResponse;
pub const DEFAULT_API_URL: &str = "https://test.api.io";
pub const DEFAULT_APP_NAME: &str = "moonclient";
pub const DEFAULT_MAX_RESPONSE_SIZE: usize = 16 * 1024 * 1024;
pub(crate) type ClientRateLimiter =
RateLimiter<NotKeyed, governor::state::InMemoryState, DefaultClock>;
#[derive(Clone, Default)]
pub struct RateLimitStrategy {
pub(crate) limiters: Arc<Vec<(Duration, Arc<ClientRateLimiter>)>>,
}
#[derive(Clone)]
pub struct MoonClient<H: ClientHook> {
pub(crate) http: ClientWithMiddleware,
pub(crate) inner: Client,
pub(crate) base_url: url::Url,
pub(crate) user_agent: String,
pub(crate) timeout: Arc<std::sync::RwLock<Option<Duration>>>,
pub(crate) limiter: Arc<dyn crate::limiter::RequestLimiter>,
pub(crate) max_response_size: Arc<AtomicUsize>,
pub(crate) hook: Arc<H>,
}
impl<H: ClientHook> MoonClient<H> {
pub fn builder(hook: H) -> MoonClientBuilder<H> {
MoonClientBuilder::new(hook)
}
pub fn get<U: reqwest::IntoUrl>(&self, url: U) -> RequestBuilder {
self.http.get(url)
}
pub fn post<U: reqwest::IntoUrl>(&self, url: U) -> RequestBuilder {
self.http.post(url)
}
pub fn put<U: reqwest::IntoUrl>(&self, url: U) -> RequestBuilder {
self.http.put(url)
}
pub fn patch<U: reqwest::IntoUrl>(&self, url: U) -> RequestBuilder {
self.http.patch(url)
}
pub fn delete<U: reqwest::IntoUrl>(&self, url: U) -> RequestBuilder {
self.http.delete(url)
}
pub fn head<U: reqwest::IntoUrl>(&self, url: U) -> RequestBuilder {
self.http.head(url)
}
pub fn request<U: reqwest::IntoUrl>(&self, method: reqwest::Method, url: U) -> RequestBuilder {
self.http.request(method, url)
}
pub fn base_url(&self) -> &url::Url {
&self.base_url
}
pub fn max_response_size(&self) -> usize {
self.max_response_size.load(Ordering::Relaxed)
}
pub fn set_max_response_size(&self, bytes: usize) {
self.max_response_size.store(bytes, Ordering::Relaxed);
}
pub fn hook(&self) -> &Arc<H> {
&self.hook
}
pub fn user_agent(&self) -> &str {
&self.user_agent
}
pub fn inner(&self) -> &Client {
&self.inner
}
pub(crate) fn apply_user_agent(&self, request: RequestBuilder) -> RequestBuilder {
request.header(reqwest::header::USER_AGENT, &self.user_agent)
}
pub fn set_timeout(&self, timeout: Option<Duration>) {
let mut t = self.timeout.write().unwrap_or_else(|e| e.into_inner());
*t = timeout;
match timeout {
Some(d) => log::debug!(
"{}",
crate::tr!("timeout-changed", "timeout" => format!("{:?}", d))
),
None => log::debug!("{}", crate::tr!("timeout-disabled")),
}
}
pub(crate) fn apply_timeout(&self, request: RequestBuilder) -> RequestBuilder {
let timeout_setting = {
let t = self.timeout.read().unwrap_or_else(|e| e.into_inner());
*t
};
match timeout_setting {
Some(duration) => request.timeout(duration),
None => request,
}
}
pub fn set_limit(&self, requests: u32, window: Duration) {
self.limiter.set_limit(requests, window);
log::info!(
"{}",
crate::tr!("limit-rule-changed", "requests" => requests, "window" => format!("{:?}", window))
);
}
pub fn set_requests_per_second(&self, rps: u32) {
self.set_limit(rps, Duration::from_secs(1));
}
pub fn set_requests_per_minute(&self, rpm: u32) {
self.set_limit(rpm, Duration::from_secs(60));
}
pub fn set_limits_bulk(&self, limits: Vec<(u32, Duration)>) {
for &(count, duration) in &limits {
if count == 0 || duration.is_zero() {
log::warn!(
"{}",
crate::tr!("limit-invalid-ignored", "count" => count, "duration" => format!("{:?}", duration))
);
}
}
self.limiter.set_limits_bulk(limits);
log::info!("{}", crate::tr!("limit-strategy-reset"));
}
pub async fn wait_for_limits(&self) -> Result<()> {
self.limiter.wait().await
}
pub async fn execute<T>(&self, mut request: RequestBuilder) -> Result<T>
where
T: FromResponse,
{
let retry_request = request.try_clone();
request = self
.hook
.pre_request(request)
.await
.map_err(|e| MoonError::Middleware(e.to_string()))?;
request = self.apply_user_agent(request);
request = self.apply_timeout(request);
let request_url = request
.try_clone()
.and_then(|r| r.build().ok())
.map(|r| r.url().to_string())
.unwrap_or_else(|| "<unknown>".to_string());
self.wait_for_limits().await?;
log::debug!(
"{}",
crate::tr!("network-request-sending", "url" => request_url.clone())
);
let response = request.send().await?;
log::debug!(
"{}",
crate::tr!("network-response-received", "url" => response.url().to_string())
);
let status = response.status();
if status == reqwest::StatusCode::UNAUTHORIZED {
let refreshed = self
.hook
.handle_unauthorized()
.await
.map_err(|e| MoonError::Middleware(e.to_string()))?;
if refreshed {
log::info!("{}", crate::tr!("request-retrying"));
if let Some(mut retry) = retry_request {
retry = self
.hook
.pre_request(retry)
.await
.map_err(|e| MoonError::Middleware(e.to_string()))?;
retry = self.apply_timeout(retry);
let retry_response = retry.send().await?;
return T::from_response(retry_response).await;
}
}
}
T::from_response(response).await
}
pub async fn download(&self, mut request: RequestBuilder) -> Result<Bytes> {
request = self.apply_user_agent(request);
self.wait_for_limits().await?;
let response = request.send().await?;
log::debug!(
"{}",
crate::tr!("network-download-started", "url" => response.url().to_string())
);
if response.status().is_client_error() || response.status().is_server_error() {
return Err(MoonError::ApiError {
code: response.status().as_u16(),
message: response.status().to_string(),
});
}
let bytes = response.bytes().await?;
Ok(bytes)
}
pub async fn save_file(&self, request: RequestBuilder, path: impl AsRef<Path>) -> Result<()> {
let bytes = self.download(request).await?;
if let Some(parent) = path.as_ref().parent() {
if !parent.exists() {
tokio::fs::create_dir_all(parent).await?;
}
}
let mut file = tokio::fs::File::create(path).await?;
file.write_all(&bytes).await?;
Ok(())
}
}
pub struct MoonClientBuilder<H: ClientHook> {
base_url: String,
user_agent: String,
limits: Vec<(u32, Duration)>,
max_retries: u32,
timeout: Option<Duration>,
custom_limiter: Option<Arc<dyn crate::limiter::RequestLimiter>>,
max_response_size: usize,
hook: H,
}
impl<H: ClientHook> MoonClientBuilder<H> {
pub fn new(hook: H) -> Self {
Self {
base_url: DEFAULT_API_URL.to_string(),
user_agent: DEFAULT_APP_NAME.to_string(),
limits: vec![
(5, Duration::from_secs(1)), (90, Duration::from_secs(60)), ],
max_retries: 3,
timeout: Some(Duration::from_secs(60)),
custom_limiter: None,
max_response_size: DEFAULT_MAX_RESPONSE_SIZE,
hook,
}
}
pub fn with_base_url(mut self, base_url: impl Into<String>) -> Self {
self.base_url = base_url.into();
self
}
pub fn with_app_name(mut self, app_name: impl Into<String>) -> Self {
self.user_agent = app_name.into();
self
}
pub fn with_max_retries(mut self, retries: u32) -> Self {
self.max_retries = retries;
self
}
pub fn with_timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
pub fn with_infinite_timeout(mut self) -> Self {
self.timeout = None;
self
}
pub fn clear_limits(mut self) -> Self {
self.limits.clear();
self
}
pub fn add_limit(mut self, requests: u32, window: Duration) -> Self {
self.limits.retain(|(_, d)| *d != window);
if requests > 0 && !window.is_zero() {
self.limits.push((requests, window));
}
self
}
pub fn requests_per_second(self, rps: u32) -> Self {
self.add_limit(rps, Duration::from_secs(1))
}
pub fn requests_per_minute(self, rpm: u32) -> Self {
self.add_limit(rpm, Duration::from_secs(60))
}
pub fn with_custom_limiter(mut self, limiter: impl crate::limiter::RequestLimiter) -> Self {
self.custom_limiter = Some(Arc::new(limiter));
self
}
pub fn with_max_response_size(mut self, bytes: usize) -> Self {
self.max_response_size = bytes;
self
}
pub fn build(self) -> MoonClient<H> {
let retry_policy = ExponentialBackoff::builder().build_with_max_retries(self.max_retries);
let client_inner = Client::new();
let http = ClientBuilder::new(client_inner.clone())
.with(MoonRetryMiddleware::new_with_policy(retry_policy))
.build();
let parsed_url = url::Url::parse(self.base_url.trim_end_matches('/'))
.expect(&crate::tr!("expect-invalid-base-url"));
if parsed_url.cannot_be_a_base() {
panic!("{}", crate::tr!("expect-invalid-base-url"));
}
let limiter: Arc<dyn crate::limiter::RequestLimiter> = match self.custom_limiter {
Some(custom) => custom,
None => {
let mut strategy_limiters = Vec::with_capacity(self.limits.len());
for &(count, duration) in &self.limits {
let limiter = create_limiter(count, duration);
strategy_limiters.push((duration, limiter));
}
let strategy = RateLimitStrategy {
limiters: Arc::new(strategy_limiters),
};
Arc::new(crate::limiter::InMemoryLimiter::new(strategy))
}
};
MoonClient {
http,
inner: client_inner,
base_url: parsed_url,
user_agent: self.user_agent,
timeout: Arc::new(std::sync::RwLock::new(self.timeout)),
limiter,
max_response_size: Arc::new(AtomicUsize::new(self.max_response_size)),
hook: Arc::new(self.hook),
}
}
}
pub struct MoonRetryMiddleware<
T: RetryPolicy + Send + Sync + 'static,
R: RetryableStrategy + Send + Sync + 'static = DefaultRetryableStrategy,
> {
inner: RetryTransientMiddleware<T, R>,
}
impl<T: RetryPolicy + Send + Sync + 'static> MoonRetryMiddleware<T, DefaultRetryableStrategy> {
pub fn new_with_policy(retry_policy: T) -> Self {
Self {
inner: RetryTransientMiddleware::new_with_policy(retry_policy),
}
}
}
impl<T, R> MoonRetryMiddleware<T, R>
where
T: RetryPolicy + Send + Sync + 'static,
R: RetryableStrategy + Send + Sync + 'static,
{
pub fn new_with_policy_and_strategy(retry_policy: T, retryable_strategy: R) -> Self {
Self {
inner: RetryTransientMiddleware::new_with_policy_and_strategy(
retry_policy,
retryable_strategy,
),
}
}
}
#[async_trait]
impl<T, R> Middleware for MoonRetryMiddleware<T, R>
where
T: RetryPolicy + Send + Sync + 'static,
R: RetryableStrategy + Send + Sync + 'static,
{
async fn handle(
&self,
req: reqwest::Request,
extensions: &mut http::Extensions,
next: Next<'_>,
) -> MiddlewareResult<reqwest::Response> {
if req.try_clone().is_none() {
return next.run(req, extensions).await;
}
self.inner.handle(req, extensions, next).await
}
}
pub(crate) fn create_limiter(count: u32, duration: Duration) -> Arc<ClientRateLimiter> {
let count_nz = NonZeroU32::new(count).expect(&crate::tr!("expect-limit-greater-than-zero"));
let quota = if duration.as_secs() == 1 {
Quota::per_second(count_nz)
} else if duration.as_secs() == 60 {
Quota::per_minute(count_nz)
} else {
let total_nanos = duration.as_nanos();
let nanos_per_token = total_nanos / (count as u128);
let period = Duration::from_nanos(nanos_per_token as u64);
Quota::with_period(period)
.expect(&crate::tr!("expect-invalid-period-calculation"))
.allow_burst(count_nz)
};
Arc::new(RateLimiter::direct(quota))
}