arc-web 0.3.0

Arc framework runtime: Actix/Tera web machinery, event-sourcing wiring, and the application builder seam.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use crate::helpers::rate_limit::RateLimiter;
use actix_web::{
    body::MessageBody,
    dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform},
    web, Error,
};
use futures_util::future::LocalBoxFuture;
use std::future::{ready, Ready};

/// Middleware factory for global rate limiting
pub struct GlobalRateLimit;

impl<S, B> Transform<S, ServiceRequest> for GlobalRateLimit
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: MessageBody + 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type InitError = ();
    type Transform = GlobalRateLimitMiddleware<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(GlobalRateLimitMiddleware { service }))
    }
}

pub struct GlobalRateLimitMiddleware<S> {
    service: S,
}

impl<S, B> Service<ServiceRequest> for GlobalRateLimitMiddleware<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: MessageBody + 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        let path = req.path().to_string();

        // Skip rate limiting for health check and static files
        if path == "/health" || path.starts_with("/public/") {
            let fut = self.service.call(req);
            return Box::pin(fut);
        }

        let ip = req
            .connection_info()
            .realip_remote_addr()
            .unwrap_or("unknown")
            .to_string();
        let key = format!("global:{}", ip);

        // Clone the limiter reference
        let limiter = req.app_data::<web::Data<RateLimiter>>().cloned();

        let fut = self.service.call(req);

        Box::pin(async move {
            if let Some(limiter) = limiter {
                match limiter.check(key) {
                    Ok(()) => {
                        // Request allowed
                    }
                    Err(retry_after) => {
                        tracing::warn!(ip = %ip, path = %path, "Global rate limit exceeded");

                        return Err(actix_web::error::ErrorTooManyRequests(format!(
                            "Rate limit exceeded. Retry after {} seconds",
                            retry_after.as_secs()
                        )));
                    }
                }
            }

            fut.await
        })
    }
}