kegani 0.1.1

A developer-friendly, ergonomic, production-ready Rust web framework
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
88
89
90
91
92
93
94
95
96
97
98

//! Timeout middleware
//!
//! Provides request timeout handling.

use actix_web::{
    dev::{Service, ServiceRequest, ServiceResponse, Transform},
    Error,
};
use std::future::{ready, Ready};
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::Duration;
use tokio::time::timeout;

/// Timeout configuration
#[derive(Debug, Clone)]
pub struct TimeoutConfig {
    pub duration: Duration,
}

impl TimeoutConfig {
    /// Create a new timeout config with the given duration
    pub fn new(duration: Duration) -> Self {
        Self { duration }
    }
}

/// Timeout middleware
pub struct Timeout {
    config: TimeoutConfig,
}

impl Timeout {
    /// Create a new Timeout middleware
    pub fn new(duration: Duration) -> Self {
        Self {
            config: TimeoutConfig { duration },
        }
    }
}

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

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(TimeoutMiddleware {
            service,
            duration: self.config.duration,
        }))
    }
}

pub struct TimeoutMiddleware<S> {
    service: S,
    duration: Duration,
}

impl<S, B> Service<ServiceRequest> for TimeoutMiddleware<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = Pin<Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>>>>;

    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

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

        Box::pin(async move {
            match timeout(duration, fut).await {
                Ok(result) => result,
                Err(_) => {
                    tracing::warn!(path = %path, "Request timeout");
                    Err(actix_web::error::ErrorRequestTimeout(
                        "Request timeout. Please try again."
                    ))
                }
            }
        })
    }
}