use axum::Json;
use axum::extract::Request;
use axum::http::StatusCode;
use axum::middleware::Next;
use axum::response::{IntoResponse, Response};
use std::collections::HashMap;
use std::pin::Pin;
use std::sync::Mutex;
use std::time::{Duration, Instant};
pub struct RateLimiter {
inner: std::sync::Arc<Mutex<HashMap<String, ClientState>>>,
max_requests: u64,
window: Duration,
}
impl Clone for RateLimiter {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
max_requests: self.max_requests,
window: self.window,
}
}
}
#[derive(Clone)]
struct ClientState {
count: u64,
reset_at: Instant,
}
impl RateLimiter {
pub fn new(max_requests: u64, window: Duration) -> Self {
Self {
inner: std::sync::Arc::new(Mutex::new(HashMap::new())),
max_requests,
window,
}
}
pub fn per_minute(max_requests: u64) -> Self {
Self::new(max_requests, Duration::from_secs(60))
}
pub fn per_hour(max_requests: u64) -> Self {
Self::new(max_requests, Duration::from_secs(3600))
}
pub fn middleware(
self,
) -> impl Fn(Request, Next) -> Pin<Box<dyn std::future::Future<Output = Response> + Send>>
+ Clone
+ Send
+ Sync
+ 'static {
move |req: Request, next: Next| {
let limiter = self.clone();
Box::pin(async move { limiter.handle(req, next).await })
}
}
async fn handle(&self, req: Request, next: Next) -> Response {
let client_ip = req
.headers()
.get("x-forwarded-for")
.and_then(|v| v.to_str().ok())
.unwrap_or("127.0.0.1")
.to_string();
let (allowed, remaining, reset) = self.check(&client_ip);
if !allowed {
let mut resp = (
StatusCode::TOO_MANY_REQUESTS,
Json(serde_json::json!({
"message": "Too Many Requests",
"status": 429,
})),
)
.into_response();
set_headers(&mut resp, self.max_requests, remaining, reset);
return resp;
}
let mut resp = next.run(req).await;
set_headers(&mut resp, self.max_requests, remaining, reset);
resp
}
pub fn check(&self, key: &str) -> (bool, u64, Instant) {
let mut map = self.inner.lock().unwrap();
let now = Instant::now();
let state = map.entry(key.to_string()).or_insert(ClientState {
count: 0,
reset_at: now + self.window,
});
if now >= state.reset_at {
state.count = 0;
state.reset_at = now + self.window;
}
state.count += 1;
let remaining = self.max_requests.saturating_sub(state.count);
(state.count <= self.max_requests, remaining, state.reset_at)
}
}
fn set_headers(resp: &mut Response, max: u64, remaining: u64, reset: Instant) {
let headers = resp.headers_mut();
if let Ok(v) = max.to_string().parse() {
headers.insert("X-RateLimit-Limit", v);
}
if let Ok(v) = remaining.to_string().parse() {
headers.insert("X-RateLimit-Remaining", v);
}
if let Ok(v) = reset
.duration_since(Instant::now())
.as_secs()
.to_string()
.parse()
{
headers.insert("X-RateLimit-Reset", v);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_allows_within_limit() {
let limiter = RateLimiter::new(5, Duration::from_secs(60));
for _ in 0..5 {
let (allowed, remaining, _) = limiter.check("127.0.0.1");
assert!(allowed);
assert!(remaining < 5);
}
}
#[test]
fn test_blocks_after_limit() {
let limiter = RateLimiter::new(3, Duration::from_secs(60));
for _ in 0..3 {
assert!(limiter.check("10.0.0.1").0);
}
let (allowed, remaining, _) = limiter.check("10.0.0.1");
assert!(!allowed);
assert_eq!(remaining, 0);
}
#[test]
fn test_isolated_per_client() {
let limiter = RateLimiter::new(2, Duration::from_secs(60));
assert!(limiter.check("a").0);
assert!(limiter.check("b").0);
assert!(limiter.check("a").0);
assert!(!limiter.check("a").0);
assert!(limiter.check("b").0);
assert!(!limiter.check("b").0);
}
#[test]
fn test_window_reset() {
let limiter = RateLimiter::new(2, Duration::from_millis(10));
assert!(limiter.check("c").0);
assert!(limiter.check("c").0);
assert!(!limiter.check("c").0);
std::thread::sleep(Duration::from_millis(20));
assert!(limiter.check("c").0);
}
}