spacegate-kernel 0.2.0-alpha.4

A library-first, lightweight, high-performance, cloud-native supported API gateway
Documentation 
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

mod reflect;
pub use reflect::*;
mod gateway_name;
pub use gateway_name::*;
mod matched;
pub use matched::*;
mod peer_addr;
pub use peer_addr::*;
mod backend_host;
pub use backend_host::*;
mod enter_time;
pub use enter_time::*;
mod request_id;
pub use defer::*;
mod defer;
pub use original_ip_addr::*;
mod original_ip_addr;
pub use is_east_west_traffic::*;

use crate::{extractor::OptionalExtract, injector::Inject};
mod is_east_west_traffic;
pub mod user_group;
/// Just extract and attach the extension to the request
#[derive(Debug, Clone)]
pub struct Extension<E>(pub E);

impl<E> Extension<E> {
    pub const fn new(e: E) -> Self {
        Self(e)
    }

    pub fn into_inner(self) -> E {
        self.0
    }
    pub const fn inner(&self) -> &E {
        &self.0
    }
}

impl<E: Clone + Send + Sync + 'static> Inject for Extension<E> {
    fn inject(&self, req: &mut hyper::Request<crate::SgBody>) -> crate::BoxResult<()> {
        req.extensions_mut().insert(self.0.clone());
        Ok(())
    }
}

impl<E: Clone + Send + Sync + 'static> OptionalExtract for Extension<E> {
    fn extract(req: &hyper::Request<crate::SgBody>) -> Option<Self> {
        req.extensions().get::<E>().map(|e| Self(e.clone()))
    }
}

/// FromBackend is a marker type to indicate that the response is from backend.
#[derive(Debug, Clone, Copy)]
pub struct FromBackend {
    _priv: (),
}

impl FromBackend {
    /// # Safety
    ///
    /// **Ensure** the response is from the **real backend**, do not cheat on users of this type.
    pub const unsafe fn new() -> Self {
        Self { _priv: () }
    }
}