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

use std::{hash::RandomState, sync::Arc};

use host_container::HostContainer;
use once_cell::sync::Lazy;
use papaya::HashMapRef;
use routes::RouteStore;

pub mod cache;
pub mod certificates;
pub mod global;
pub mod host_container;
pub mod lookup;
pub mod memory_store;
pub mod redis_store;
pub mod routes;
#[cfg(any(feature = "store-sqlite", feature = "store-postgres"))]
pub mod sql_store;
pub mod store_trait;
pub mod stored_route;

#[cfg(test)]
pub(crate) mod contract_tests;

// Re-export stores
pub use memory_store::MemoryStore;
pub use redis_store::RedisStore;

// CHALLENGE store - DEPRECATED: Use global store instead
// static CHALLENGE_STORE: Lazy<ChallengeStore> = Lazy::new(papaya::HashMap::new);

// pub fn get_challenge_by_key(key: &str) -> Option<(String, String)> {
//     CHALLENGE_STORE.pin().get(key).cloned()
// }

// /// Insert given challenge into the store
// pub fn insert_challenge(key: String, value: (String, String)) {
//     CHALLENGE_STORE.pin().insert(key, value);
// }

/// The id of this replica in the store (heartbeats and leases): its hostname and a random
/// suffix, so replicas on one host (or restarts) are told apart
pub fn replica_id() -> &'static str {
    static REPLICA_ID: std::sync::OnceLock<String> = std::sync::OnceLock::new();
    REPLICA_ID.get_or_init(|| {
        let suffix = uuid::Uuid::new_v4().simple().to_string();
        format!("{}-{}", hostname(), suffix.get(..8).unwrap_or(&suffix))
    })
}

pub fn hostname() -> String {
    nix::unistd::gethostname()
        .ok()
        .and_then(|name| name.into_string().ok())
        .unwrap_or_else(|| "proksi".to_string())
}

// ROUTE store
static ROUTE_STORE: Lazy<RouteStore> = Lazy::new(papaya::HashMap::new);

pub fn get_route_by_key(key: &str) -> Option<Arc<HostContainer>> {
    ROUTE_STORE.pin().get(key).cloned()
}

pub fn get_routes(
) -> HashMapRef<'static, String, Arc<HostContainer>, RandomState, seize::OwnedGuard<'static>> {
    ROUTE_STORE.pin_owned()
}

pub fn insert_route(key: String, value: Arc<HostContainer>) {
    ROUTE_STORE.pin().insert(key, value);
}

pub fn remove_route(key: &str) {
    ROUTE_STORE.pin().remove(key);
}

// CERTIFICATE store
// static CERTIFICATE_STORE: Lazy<CertificateStore> = Lazy::new(papaya::HashMap::new);

// pub fn get_certificate_by_key(key: &str) -> Option<Certificate> {
//     CERTIFICATE_STORE.pin().get(key).cloned()
// }

// pub fn get_certificates(
// ) -> HashMapRef<'static, String, Certificate, RandomState, seize::LocalGuard<'static>> {
//     CERTIFICATE_STORE.pin()
// }

// pub fn insert_certificate(key: String, value: Certificate) {
//     CERTIFICATE_STORE.pin().insert(key, value);
// }

// Cache Routing store
static CACHE_ROUTING_STORE: Lazy<cache::PathCacheStorage> = Lazy::new(papaya::HashMap::new);

/// Retrieves the cache routing from the store
pub fn get_cache_routing_by_key(key: &str) -> Option<String> {
    CACHE_ROUTING_STORE.pin().get(key).cloned()
}

/// Where the cache of `key` is stored, unless it's known already
pub fn insert_cache_routing(key: &str, value: &str) {
    let store = CACHE_ROUTING_STORE.pin();
    if store.get(key).is_none() {
        store.insert(key.to_string(), value.to_string());
    }
}