tideway 0.7.17

A batteries-included Rust web framework built on Axum for building SaaS applications quickly
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::utils::get_env_with_prefix;
use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Timeout configuration for Tideway applications
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TimeoutConfig {
    /// Whether timeout is enabled
    #[serde(default = "default_enabled")]
    pub enabled: bool,

    /// Request timeout duration in seconds
    #[serde(default = "default_timeout_seconds")]
    pub timeout_seconds: u64,
}

impl Default for TimeoutConfig {
    fn default() -> Self {
        Self {
            enabled: default_enabled(),
            timeout_seconds: default_timeout_seconds(),
        }
    }
}

impl TimeoutConfig {
    /// Create a new TimeoutConfig builder
    pub fn builder() -> TimeoutConfigBuilder {
        TimeoutConfigBuilder::new()
    }

    /// Get the timeout duration
    pub fn duration(&self) -> Duration {
        Duration::from_secs(self.timeout_seconds)
    }

    /// Load timeout configuration from environment variables
    pub fn from_env() -> Self {
        let mut config = Self::default();

        if let Some(enabled) = get_env_with_prefix("TIMEOUT_ENABLED") {
            match enabled.parse() {
                Ok(value) => config.enabled = value,
                Err(_) => {
                    tracing::warn!(
                        value = %enabled,
                        "Invalid TIMEOUT_ENABLED (expected true/false), using default ({})",
                        default_enabled()
                    );
                }
            }
        }

        if let Some(seconds) = get_env_with_prefix("TIMEOUT_SECONDS") {
            match seconds.parse() {
                Ok(s) => config.timeout_seconds = s,
                Err(_) => tracing::warn!(
                    value = %seconds,
                    "Invalid TIMEOUT_SECONDS (expected integer), using default ({})",
                    default_timeout_seconds()
                ),
            }
        }

        config
    }
}

/// Builder for TimeoutConfig
#[must_use = "builder does nothing until you call build()"]
pub struct TimeoutConfigBuilder {
    config: TimeoutConfig,
}

impl TimeoutConfigBuilder {
    pub fn new() -> Self {
        Self {
            config: TimeoutConfig::default(),
        }
    }

    pub fn enabled(mut self, enabled: bool) -> Self {
        self.config.enabled = enabled;
        self
    }

    pub fn timeout_seconds(mut self, seconds: u64) -> Self {
        self.config.timeout_seconds = seconds;
        self
    }

    pub fn timeout(mut self, duration: Duration) -> Self {
        self.config.timeout_seconds = duration.as_secs();
        self
    }

    pub fn build(self) -> TimeoutConfig {
        self.config
    }
}

impl Default for TimeoutConfigBuilder {
    fn default() -> Self {
        Self::new()
    }
}

fn default_enabled() -> bool {
    true
}

fn default_timeout_seconds() -> u64 {
    30 // 30 seconds default timeout
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_config() {
        let config = TimeoutConfig::default();
        assert!(config.enabled);
        assert_eq!(config.timeout_seconds, 30);
        assert_eq!(config.duration(), Duration::from_secs(30));
    }

    #[test]
    fn test_builder() {
        let config = TimeoutConfig::builder().timeout_seconds(60).build();

        assert_eq!(config.timeout_seconds, 60);
        assert_eq!(config.duration(), Duration::from_secs(60));
    }

    #[test]
    fn test_duration() {
        let config = TimeoutConfig::builder()
            .timeout(Duration::from_secs(45))
            .build();

        assert_eq!(config.timeout_seconds, 45);
    }
}