rift-http-proxy 0.4.0

Rift: high-performance HTTP chaos engineering proxy with Lua/Rhai/JavaScript scripting for fault injection.
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Upstream and connection pool configuration.

use super::protocol::Protocol;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct UpstreamConfig {
    pub host: String,
    pub port: u16,
    /// Protocol: http or https (default: http)
    /// Note: 'scheme' is deprecated but maintained for backward compatibility
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<Protocol>,
    /// Deprecated: use 'protocol' instead
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
    /// Skip TLS certificate verification (for self-signed certs in dev/test)
    #[serde(default)]
    pub tls_skip_verify: bool,
}

impl UpstreamConfig {
    /// Get the protocol, checking both new 'protocol' field and legacy 'scheme' field
    pub fn get_protocol(&self) -> Protocol {
        // Prefer new 'protocol' field
        if let Some(protocol) = self.protocol {
            return protocol;
        }

        // Fall back to legacy 'scheme' field
        if let Some(ref scheme) = self.scheme {
            Protocol::from_scheme(scheme).unwrap_or(Protocol::Http)
        } else {
            Protocol::Http
        }
    }
}

/// Named upstream for reverse proxy mode
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Upstream {
    pub name: String,
    pub url: String,
    #[serde(default)]
    pub health_check: Option<HealthCheckConfig>,
    /// Skip TLS certificate verification (for self-signed certs in dev/test)
    #[serde(default)]
    pub tls_skip_verify: bool,
}

impl Upstream {
    /// Parse and extract protocol from URL
    /// Returns the protocol or an error if URL is invalid or protocol is unsupported
    pub fn get_protocol(&self) -> Result<Protocol, String> {
        // Parse URL to extract scheme
        let url_parts: Vec<&str> = self.url.splitn(2, "://").collect();
        if url_parts.len() != 2 {
            return Err(format!("Invalid URL format (missing scheme): {}", self.url));
        }

        Protocol::from_scheme(url_parts[0])
    }

    /// Validate that the upstream configuration is valid
    pub fn validate(&self) -> Result<(), String> {
        // Check protocol is valid and supported
        let protocol = self.get_protocol()?;
        if !protocol.is_supported() {
            return Err(format!(
                "Unsupported protocol '{}' for upstream '{}'. Currently supported: http, https",
                protocol.as_str(),
                self.name
            ));
        }
        Ok(())
    }
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct HealthCheckConfig {
    #[serde(default = "default_health_path")]
    pub path: String,
    #[serde(default = "default_health_interval")]
    pub interval_seconds: u64,
    #[serde(default = "default_health_timeout")]
    pub timeout_seconds: u64,
    #[serde(default = "default_health_unhealthy_threshold")]
    pub unhealthy_threshold: u32,
    #[serde(default = "default_health_healthy_threshold")]
    pub healthy_threshold: u32,
}

fn default_health_path() -> String {
    "/health".to_string()
}

fn default_health_interval() -> u64 {
    30
}

fn default_health_timeout() -> u64 {
    5
}

fn default_health_unhealthy_threshold() -> u32 {
    3
}

fn default_health_healthy_threshold() -> u32 {
    2
}

impl Default for HealthCheckConfig {
    fn default() -> Self {
        Self {
            path: default_health_path(),
            interval_seconds: default_health_interval(),
            timeout_seconds: default_health_timeout(),
            unhealthy_threshold: default_health_unhealthy_threshold(),
            healthy_threshold: default_health_healthy_threshold(),
        }
    }
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ConnectionPoolConfig {
    #[serde(default = "default_pool_max_idle_per_host")]
    pub max_idle_per_host: usize,

    #[serde(default = "default_pool_idle_timeout")]
    pub idle_timeout_secs: u64,

    #[serde(default = "default_keepalive_timeout")]
    pub keepalive_timeout_secs: u64,

    #[serde(default = "default_connect_timeout")]
    pub connect_timeout_secs: u64,
}

impl Default for ConnectionPoolConfig {
    fn default() -> Self {
        Self {
            max_idle_per_host: default_pool_max_idle_per_host(),
            idle_timeout_secs: default_pool_idle_timeout(),
            keepalive_timeout_secs: default_keepalive_timeout(),
            connect_timeout_secs: default_connect_timeout(),
        }
    }
}

fn default_pool_max_idle_per_host() -> usize {
    100
}

fn default_pool_idle_timeout() -> u64 {
    90
}

fn default_keepalive_timeout() -> u64 {
    60
}

fn default_connect_timeout() -> u64 {
    5
}