proksi 0.7.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

use path_tree::PathTree;

use super::normalize::normalize_path;

/// Finds the location serving a path: the most specific match (a static path beats
/// a parameter, which beats a wildcard), after normalizing the path
#[derive(Default)]
pub struct LocationMatcher {
    /// Pattern -> index of the location
    tree: PathTree<usize>,
}

impl LocationMatcher {
    /// Takes the path patterns of each location, in order (the index identifies the location)
    pub fn new(locations: impl IntoIterator<Item = Vec<String>>) -> Self {
        let mut tree = PathTree::new();
        for (index, patterns) in locations.into_iter().enumerate() {
            for pattern in patterns {
                let _ = tree.insert(&pattern, index);
            }
        }
        Self { tree }
    }

    /// Index of the location serving `path`, if any
    pub fn find(&self, path: &str) -> Option<usize> {
        self.tree
            .find(&normalize_path(path))
            .map(|(index, _)| *index)
    }
}

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

    fn patterns(patterns: &[&str]) -> Vec<String> {
        patterns.iter().map(ToString::to_string).collect()
    }

    /// `/*` (0), `/v1/session` and below (1), exactly `/auth` (2)
    fn matcher() -> LocationMatcher {
        LocationMatcher::new([
            patterns(&["/*"]),
            patterns(&["/v1/session", "/v1/session/*"]),
            patterns(&["/auth"]),
        ])
    }

    #[test]
    fn test_most_specific_location_wins() {
        let matcher = matcher();
        assert_eq!(matcher.find("/"), Some(0));
        assert_eq!(matcher.find("/v1/session"), Some(1));
        assert_eq!(matcher.find("/v1/session/"), Some(1));
        assert_eq!(matcher.find("/v1/session/x/y"), Some(1));
        assert_eq!(matcher.find("/v1/sessions"), Some(0));
    }

    #[test]
    fn test_exact_location_only_matches_its_path() {
        let matcher = matcher();
        assert_eq!(matcher.find("/auth"), Some(2));
        assert_eq!(matcher.find("/auth/x"), Some(0));
    }

    #[test]
    fn test_paths_are_normalized_before_matching() {
        let matcher = matcher();
        assert_eq!(matcher.find("//v1/session"), Some(1));
        assert_eq!(matcher.find("/v1//session"), Some(1));
        assert_eq!(matcher.find("/x/../v1/session"), Some(1));
        assert_eq!(matcher.find("/v1/./session"), Some(1));
    }

    #[test]
    fn test_no_matching_location() {
        let matcher = LocationMatcher::new([patterns(&["/api/*"])]);
        assert_eq!(matcher.find("/other"), None);
    }
}