use async_trait::async_trait;
use std::sync::Arc;
use crate::client::RateLimitStrategy;
use crate::error::Result;
#[cfg(feature = "redis-limit")]
use crate::error::MoonError;
#[cfg(feature = "redis-limit")]
use std::time::Duration;
#[cfg(feature = "redis-limit")]
use tokio::time::sleep;
#[async_trait]
pub trait RequestLimiter: Send + Sync + 'static {
async fn wait(&self) -> Result<()>;
fn set_limit(&self, _requests: u32, _window: std::time::Duration) {}
fn set_limits_bulk(&self, _limits: Vec<(u32, std::time::Duration)>) {}
}
pub struct InMemoryLimiter {
pub(crate) strategy: Arc<std::sync::RwLock<RateLimitStrategy>>,
}
impl InMemoryLimiter {
pub fn new(strategy: RateLimitStrategy) -> Self {
Self {
strategy: Arc::new(std::sync::RwLock::new(strategy)),
}
}
}
impl Default for InMemoryLimiter {
fn default() -> Self {
Self::new(RateLimitStrategy::default())
}
}
#[async_trait]
impl RequestLimiter for InMemoryLimiter {
async fn wait(&self) -> Result<()> {
let limiters = {
let state = self.strategy.read().unwrap_or_else(|e| e.into_inner());
state.limiters.clone()
};
for (_, limiter) in limiters.iter() {
limiter.until_ready().await;
}
Ok(())
}
fn set_limit(&self, requests: u32, window: std::time::Duration) {
let mut strategy = self.strategy.write().unwrap_or_else(|e| e.into_inner());
let mut limiters_vec = (*strategy.limiters).clone();
limiters_vec.retain(|(d, _)| *d != window);
if requests > 0 && !window.is_zero() {
let limiter = crate::client::create_limiter(requests, window);
limiters_vec.push((window, limiter));
}
strategy.limiters = Arc::new(limiters_vec);
}
fn set_limits_bulk(&self, limits: Vec<(u32, std::time::Duration)>) {
let mut new_limiters = Vec::new();
for (count, duration) in limits {
if count == 0 || duration.is_zero() {
continue;
}
let limiter = crate::client::create_limiter(count, duration);
new_limiters.push((duration, limiter));
}
let mut strategy = self.strategy.write().unwrap_or_else(|e| e.into_inner());
strategy.limiters = Arc::new(new_limiters);
}
}
#[cfg(feature = "redis-limit")]
pub struct RedisLimiter {
connection_manager: redis::aio::ConnectionManager,
limit_key: String,
limit: u32,
window_ms: u64,
}
#[cfg(feature = "redis-limit")]
impl RedisLimiter {
pub async fn new(
client: redis::Client,
limit_key: impl Into<String>,
limit: u32,
window: Duration,
) -> Result<Self> {
let connection_manager = client
.get_connection_manager()
.await
.map_err(|e| MoonError::Config(e.to_string()))?;
Ok(Self {
connection_manager,
limit_key: limit_key.into(),
limit,
window_ms: window.as_millis() as u64,
})
}
}
#[cfg(feature = "redis-limit")]
#[async_trait]
impl RequestLimiter for RedisLimiter {
async fn wait(&self) -> Result<()> {
let mut conn = self.connection_manager.clone();
let script = redis::Script::new(
r#"
local key = KEYS[1]
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local limit = tonumber(ARGV[3])
local clear_before = now - window
-- Evict stale entries falling outside the active sliding window
redis.call('ZREMRANGEBYSCORE', key, '-inf', clear_before)
-- Retrieve current request count within the window
local amount = redis.call('ZCARD', key)
if amount < limit then
-- Quota available: record request and permit immediate dispatch (0 ms wait)
redis.call('ZADD', key, now, now)
return 0
else
-- Limit reached: compute time remaining until earliest slot is liberated
local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')
if #oldest > 0 then
local oldest_score = tonumber(oldest[2])
local wait_time = (oldest_score + window) - now
return wait_time
end
return window
end
"#,
);
loop {
let now_ms = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as u64;
let wait_time_ms: u64 = script
.key(&self.limit_key)
.arg(now_ms)
.arg(self.window_ms)
.arg(self.limit)
.invoke_async(&mut conn)
.await
.map_err(|e| {
let err_msg = crate::tr!("redis-limit-error", "error" => e.to_string());
log::error!("{}", err_msg);
MoonError::Network(err_msg)
})?;
if wait_time_ms == 0 {
break;
}
log::debug!(
"{}",
crate::tr!(
"redis-limit-waiting",
"key" => &self.limit_key,
"duration" => wait_time_ms
)
);
sleep(Duration::from_millis(wait_time_ms)).await;
}
Ok(())
}
}