proksi 0.10.0

A batteries-included reverse proxy with automatic HTTPS using Cloudflare Pingora and Let's Encrypt.
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

//! Routes (`routes = [...]`, docker labels, stored routes with schema version 1) as hosts

use std::collections::HashSet;

use crate::config::Route;

use super::{Host, HostTls, Location};

impl Host {
    /// Converts a route. Each path pattern becomes an exact location with the route's
    /// settings, or `/*` without patterns (routes matched their patterns exactly).
    pub fn from_route(route: &Route) -> Self {
        let mut seen = HashSet::new();
        let mut paths = route
            .match_with
            .as_ref()
            .and_then(|matcher| matcher.path.as_ref())
            .map(|path| {
                path.patterns
                    .iter()
                    .map(ToString::to_string)
                    .collect::<Vec<_>>()
            })
            .unwrap_or_default();
        paths.retain(|path| seen.insert(path.clone()));
        if paths.is_empty() {
            paths.push("/*".to_string());
        }

        Self {
            name: route.host.to_string(),
            listen: vec![],
            tls: HostTls {
                enabled: true,
                certificate: route.ssl.as_ref().and_then(|ssl| ssl.path.clone()),
                self_signed_on_failure: route
                    .ssl_certificate
                    .as_ref()
                    .and_then(|ssl| ssl.self_signed_on_failure)
                    .unwrap_or(false),
            },
            locations: paths
                .into_iter()
                .map(|path| Location {
                    path,
                    exact: true,
                    upstreams: route.upstreams.clone(),
                    headers: route.headers.clone(),
                    plugins: route.plugins.clone(),
                    cache: route.cache.clone(),
                    timeouts: None,
                    rewrite: None,
                })
                .collect(),
        }
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use crate::{
        config::{
            host::{Host, HostTls},
            RouteSslPath,
        },
        routing::test_utils::route,
    };

    #[test]
    fn test_host_from_route_without_patterns() {
        let mut route = route("A.test", "10.0.0.1");
        route.ssl = Some(
            serde_json::from_value(serde_json::json!({
                "path": { "key": "/certs/a.key", "pem": "/certs/a.pem" }
            }))
            .unwrap(),
        );

        let host = Host::from_route(&route);

        assert_eq!(host.name, "A.test");
        assert_eq!(
            host.tls,
            HostTls {
                enabled: true,
                certificate: Some(RouteSslPath {
                    key: PathBuf::from("/certs/a.key"),
                    pem: PathBuf::from("/certs/a.pem"),
                }),
                self_signed_on_failure: false,
            }
        );
        assert_eq!(host.locations.len(), 1);
        assert_eq!(host.locations[0].path, "/*");
        assert_eq!(host.locations[0].upstreams, route.upstreams);
    }

    #[test]
    fn test_host_from_route_with_patterns_keeps_exact_matching() {
        let mut route = route("a.test", "10.0.0.1");
        route.match_with = Some(
            serde_json::from_value(serde_json::json!({
                "path": { "patterns": ["/api/*", "/auth", "/auth"] }
            }))
            .unwrap(),
        );
        route.ssl_certificate = Some(
            serde_json::from_value(serde_json::json!({ "self_signed_on_failure": true })).unwrap(),
        );

        let host = Host::from_route(&route);

        let paths = host
            .locations
            .iter()
            .map(|l| (l.path.as_str(), l.exact))
            .collect::<Vec<_>>();
        assert_eq!(paths, vec![("/api/*", true), ("/auth", true)]);
        assert!(host
            .locations
            .iter()
            .all(|l| l.upstreams == route.upstreams));
        assert!(host.tls.self_signed_on_failure);
    }
}