Skip to main content

threexui_rs/models/
server.rs

1use serde::Deserialize;
2
3#[derive(Debug, Clone, Deserialize)]
4#[serde(rename_all = "camelCase")]
5pub struct ResourceStat {
6    pub current: u64,
7    pub total: u64,
8}
9
10#[derive(Debug, Clone, Deserialize)]
11#[serde(rename_all = "camelCase")]
12pub struct XrayState {
13    pub state: String,
14    pub error_msg: String,
15    pub version: String,
16}
17
18#[derive(Debug, Clone, Deserialize)]
19#[serde(rename_all = "camelCase")]
20pub struct NetIO {
21    pub up: u64,
22    pub down: u64,
23}
24
25#[derive(Debug, Clone, Deserialize)]
26#[serde(rename_all = "camelCase")]
27pub struct NetTraffic {
28    pub sent: u64,
29    pub recv: u64,
30}
31
32#[derive(Debug, Clone, Deserialize)]
33#[serde(rename_all = "camelCase")]
34pub struct PublicIP {
35    #[serde(rename = "ipv4")]
36    pub ipv4: String,
37    #[serde(rename = "ipv6")]
38    pub ipv6: String,
39}
40
41#[derive(Debug, Clone, Deserialize)]
42#[serde(rename_all = "camelCase")]
43pub struct AppStats {
44    pub threads: u32,
45    pub mem: u64,
46    pub uptime: u64,
47}
48
49#[derive(Debug, Clone, Deserialize)]
50#[serde(rename_all = "camelCase")]
51pub struct ServerStatus {
52    pub cpu: f64,
53    pub cpu_cores: i32,
54    pub logical_pro: i32,
55    pub cpu_speed_mhz: f64,
56    pub mem: ResourceStat,
57    pub swap: ResourceStat,
58    pub disk: ResourceStat,
59    pub xray: XrayState,
60    pub uptime: u64,
61    #[serde(default)]
62    pub loads: Vec<f64>,
63    pub tcp_count: i64,
64    pub udp_count: i64,
65    #[serde(rename = "netIO")]
66    pub net_io: NetIO,
67    pub net_traffic: NetTraffic,
68    #[serde(rename = "publicIP")]
69    pub public_ip: PublicIP,
70    pub app_stats: AppStats,
71}
72
73#[derive(Debug, Clone, Deserialize)]
74#[serde(rename_all = "camelCase")]
75pub struct CpuHistoryPoint {
76    pub t: i64,
77    pub cpu: f64,
78}
79
80#[derive(Debug, Clone, Deserialize)]
81pub struct UuidResponse {
82    pub uuid: String,
83}
84
85#[derive(Debug, Clone, Deserialize)]
86#[serde(rename_all = "camelCase")]
87pub struct X25519Cert {
88    pub private_key: String,
89    pub public_key: String,
90}
91
92#[derive(Debug, Clone, Deserialize)]
93pub struct Mldsa65Keys {
94    pub seed: String,
95    pub verify: String,
96}
97
98#[derive(Debug, Clone, Deserialize)]
99pub struct Mlkem768Keys {
100    pub seed: String,
101    pub client: String,
102}
103
104#[derive(Debug, Clone, Deserialize)]
105#[serde(rename_all = "camelCase")]
106pub struct EchCert {
107    pub ech_server_keys: String,
108    pub ech_config_list: String,
109}
110
111#[derive(Debug, Clone, Deserialize)]
112pub struct VlessAuth {
113    pub label: String,
114    #[serde(default)]
115    pub encryption: String,
116    #[serde(default)]
117    pub decryption: String,
118}
119
120#[derive(Debug, Clone, Deserialize)]
121pub struct VlessEncResult {
122    pub auths: Vec<VlessAuth>,
123}
124
125#[cfg(test)]
126mod tests {
127    use super::*;
128
129    #[test]
130    fn server_status_deserializes() {
131        let raw = r#"{
132            "cpu":12.5,"cpuCores":4,"logicalPro":8,"cpuSpeedMhz":3200.0,
133            "mem":{"current":2048,"total":8192},
134            "swap":{"current":0,"total":4096},
135            "disk":{"current":10240,"total":51200},
136            "xray":{"state":"running","errorMsg":"","version":"1.8.0"},
137            "uptime":3600,"loads":[0.5,0.4,0.3],
138            "tcpCount":10,"udpCount":5,
139            "netIO":{"up":1024,"down":2048},
140            "netTraffic":{"sent":102400,"recv":204800},
141            "publicIP":{"ipv4":"1.2.3.4","ipv6":"::1"},
142            "appStats":{"threads":12,"mem":65536,"uptime":3600}
143        }"#;
144        let status: ServerStatus = serde_json::from_str(raw).unwrap();
145        assert_eq!(status.cpu, 12.5);
146        assert_eq!(status.cpu_cores, 4);
147        assert_eq!(status.mem.total, 8192);
148    }
149
150    #[test]
151    fn uuid_response_deserializes() {
152        let raw = r#"{"uuid":"550e8400-e29b-41d4-a716-446655440000"}"#;
153        let u: UuidResponse = serde_json::from_str(raw).unwrap();
154        assert_eq!(u.uuid, "550e8400-e29b-41d4-a716-446655440000");
155    }
156}