hyperapi 0.2.2

An easy to use 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
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
134
135
136

use std::collections::HashMap;

use serde::{Serialize, Deserialize};


#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(tag="type", content="data")]
pub enum ConfigUpdate {
    ServiceUpdate(ServiceInfo),
    ServiceRemove(String),
    ClientUpdate(ClientInfo),
    ClientRemove(String),
    ConfigReady(bool),
}


#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GatewayConfig {
    pub apps: Vec<ClientInfo>,
    pub services: Vec<ServiceInfo>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct ClientInfo {
    pub client_id: String,
    pub app_key: String,
    pub pub_key: String,
    pub ip_whitelist: Vec<String>,
    pub services: HashMap<String, String>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct ServiceInfo {
    pub service_id: String,
    pub path: String,
    pub protocol: String,
    pub auth: AuthSetting,
    pub timeout: u32,
    pub load_balance: String,
    pub filters: Vec<FilterSetting>,
    pub sla: Vec<ServiceLevel>,
    pub upstreams: Vec<Upstream>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct ServiceLevel {
    pub name: String,
    pub filters: Vec<FilterSetting>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct Upstream {
    pub id: String,
    pub target: String,
    pub max_conn: u64,
    pub weight: u32,
    pub version: String,
    pub error_threshold: u64,
    pub error_reset: u64,
    pub retry_delay: u64,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct RateLimitSetting {
    pub interval: i32,  // seconds
    pub limit: i32,
    pub burst: i32,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct HeaderSetting {
    pub operate_on: String,
    pub injection: Vec<(String, String)>,
    pub removal: Vec<String>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct ACLSetting {
    pub access_control: String,
    pub paths: Vec<PathMatcher>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct PathMatcher {
    pub methods: String,
    pub path_pattern: String,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(tag="type", content="setting")]
pub enum FilterSetting {
    RateLimit(RateLimitSetting),
    Header(HeaderSetting),
    ACL(ACLSetting),
}


impl FilterSetting {
    pub fn get_type(setting: &FilterSetting) -> String {
        match setting {
            FilterSetting::ACL(_) => "ACL".into(),
            FilterSetting::Header(_) => "Header".into(),
            FilterSetting::RateLimit(_) => "RateLimit".into(),
        }
    }
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct AppKeyAuth {}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct JwtAuth {}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct NoAuth {}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(tag = "type")]
pub enum AuthSetting {
    None(NoAuth),
    AppKey(AppKeyAuth),
    JWT(JwtAuth),
}