use axum::{body::Body, extract::Request, response::Response};
use dashmap::DashMap;
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use std::time::{Duration, Instant};
use tower::{Layer, Service};
use wordval_core::api::ApiError;
use wordval_utils::web::TrustedProxies;
#[derive(Clone)]
pub struct RateLimitLayer {
pub requests_per_window: u64,
pub window_secs: u64,
pub store: Arc<DashMap<String, IpWindow>>,
pub trusted: Arc<TrustedProxies>,
}
pub struct IpWindow {
pub count: u64,
pub window_start: Instant,
}
impl RateLimitLayer {
pub fn start_cleanup_task(&self) {
let store = self.store.clone();
let window_dur = Duration::from_secs(self.window_secs);
let cleanup_interval = (window_dur * 2).max(Duration::from_secs(1));
tokio::spawn(async move {
loop {
tokio::time::sleep(cleanup_interval).await;
let now = Instant::now();
let before = store.len();
store.retain(|_, w| now.duration_since(w.window_start) <= window_dur);
let removed = before - store.len();
if removed > 0 {
tracing::debug!("限流器清理过期 IP 条目: {} 个", removed);
}
}
});
}
}
impl<S> Layer<S> for RateLimitLayer {
type Service = RateLimitService<S>;
fn layer(&self, inner: S) -> Self::Service {
RateLimitService {
inner,
requests_per_window: self.requests_per_window,
window_secs: self.window_secs,
store: self.store.clone(),
}
}
}
#[derive(Clone)]
pub struct RateLimitService<S> {
inner: S,
requests_per_window: u64,
window_secs: u64,
store: Arc<DashMap<String, IpWindow>>,
}
impl<S> Service<Request<Body>> for RateLimitService<S>
where
S: Service<Request<Body>, Response = Response> + Clone + Send + 'static,
S::Future: Send + 'static,
{
type Response = S::Response;
type Error = S::Error;
type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, req: Request<Body>) -> Self::Future {
let ip = req
.extensions()
.get::<super::client_identity::ClientIp>()
.map(|c| c.0.clone())
.unwrap_or_else(|| "0.0.0.0".to_string());
let max_req = self.requests_per_window;
let win_secs = self.window_secs;
let store = self.store.clone();
let window_dur = Duration::from_secs(win_secs);
let allowed = {
let now = Instant::now();
let mut entry = store.entry(ip).or_insert(IpWindow {
count: 0,
window_start: now,
});
if now.duration_since(entry.window_start) > window_dur {
entry.count = 0;
entry.window_start = now;
}
if entry.count < max_req {
entry.count += 1;
true
} else {
false
}
};
if allowed {
let replacement = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, replacement);
Box::pin(async move { inner.call(req).await })
} else {
let resp =
super::error_response(ApiError::too_many_requests("请求过于频繁,请稍后再试"));
Box::pin(async move { Ok(resp) })
}
}
}