proksi 0.11.1

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
128
129
130
131
132
133

use std::{collections::BTreeSet, sync::Arc};

use pingora::lb::{discovery::Static, selection::RoundRobin, Backend, Backends, LoadBalancer};

use crate::{
    blocks::Blocks,
    config::{
        host::{CompiledRewrite, LocationTimeouts},
        RouteCache, RouteUpstream,
    },
    metrics::LocationMetrics,
    routing::build::upstream_index,
};

use super::host_container::HostContainer;

#[derive(Clone)]
pub struct RouteStoreContainer {
    /// The location's path pattern
    pub path: String,
    pub load_balancer: Arc<LoadBalancer<RoundRobin>>,

    pub upstreams: Vec<RouteUpstream>,

    /// Building blocks (plugins, headers, cache), in the order they run
    pub blocks: Blocks,

    pub cache: Option<RouteCache>,

    /// Timeouts of the location's requests, instead of `server.timeouts`
    pub timeouts: Option<LocationTimeouts>,

    /// How the path sent to upstreams is changed
    pub rewrite: Option<CompiledRewrite>,

    /// Requests and upstreams of this location (ADR 0004)
    pub metrics: Option<LocationMetrics>,
}

impl Default for RouteStoreContainer {
    fn default() -> Self {
        RouteStoreContainer {
            path: String::new(),
            load_balancer: Arc::new(LoadBalancer::<RoundRobin>::from_backends(Backends::new(
                Static::new(BTreeSet::new()),
            ))),
            blocks: Blocks::default(),
            upstreams: Vec::new(),
            cache: None,
            timeouts: None,
            rewrite: None,
            metrics: None,
        }
    }
}

impl RouteStoreContainer {
    pub fn new(load_balancer: LoadBalancer<RoundRobin>) -> Self {
        RouteStoreContainer {
            path: String::new(),
            load_balancer: Arc::new(load_balancer),
            blocks: Blocks::default(),
            upstreams: Vec::with_capacity(5),
            cache: None,
            timeouts: None,
            rewrite: None,
            metrics: None,
        }
    }

    /// Sets the upstreams of this route (the ones its load balancer was built with)
    pub fn set_upstreams(&mut self, upstreams: Vec<RouteUpstream>) {
        self.upstreams = upstreams;
    }

    /// Whether each upstream is healthy, by the health checks: when one of its addresses is
    pub fn upstream_health(&self) -> Vec<bool> {
        let backends = self.load_balancer.backends();
        let mut healthy = vec![false; self.upstreams.len()];
        for backend in backends.get_backend().iter() {
            if let Some(slot) = upstream_index(backend).and_then(|index| healthy.get_mut(index)) {
                *slot |= backends.ready(backend);
            }
        }
        healthy
    }

    /// The upstream a backend of the load balancer came from
    pub fn upstream(&self, backend: &Backend) -> Option<(usize, &RouteUpstream)> {
        let index = upstream_index(backend)?;
        Some((index, self.upstreams.get(index)?))
    }
}

/// The hosts being served, by lowercase name (updated by the reconciler)
pub type RouteStore = papaya::HashMap<String, Arc<HostContainer>>;

#[cfg(test)]
mod tests {
    use std::borrow::Cow;

    use super::*;

    #[test]
    fn test_router_container_finds_the_upstream_of_a_backend() {
        let upstreams = vec![
            RouteUpstream {
                ip: Cow::Borrowed("127.0.0.1"),
                port: 8080,
                sni: Some("ip.test".to_string()),
                ..RouteUpstream::default()
            },
            RouteUpstream {
                ip: Cow::Borrowed("localhost"),
                port: 9090,
                sni: Some("hostname.test".to_string()),
                ..RouteUpstream::default()
            },
        ];
        let mut route_store =
            RouteStoreContainer::new(crate::routing::build::load_balancer(&upstreams));
        route_store.set_upstreams(upstreams);

        let backends = route_store.load_balancer.backends().get_backend();
        let sni = |addr: &str| {
            let backend = backends.iter().find(|b| b.addr.to_string() == addr)?;
            route_store.upstream(backend)?.1.sni.clone()
        };
        assert_eq!(sni("127.0.0.1:8080").as_deref(), Some("ip.test"));
        assert_eq!(sni("127.0.0.1:9090").as_deref(), Some("hostname.test"));
        assert!(sni("127.0.0.1:1234").is_none());
    }
}