chml_api 0.8.0

Rust SDK for ChmlFrp
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

use super::schema::Tunnel;
use crate::{prelude::*, tunnel::schema::TunnelUpdate};

/// get_tunnels
pub async fn get_tunnels(chml_api: &ChmlApi) -> ApiResult<Vec<Tunnel>> {
    let api_url = chml_api.endpoint("/tunnel");

    let req = chml_api
        .client
        .get(api_url)
        .query(&[("token", chml_api.get_token()?)])
        .build()?;
    debug!("get tunnels request: {:?}", req.url());

    let res = chml_api
        .client
        .execute(req)
        .await?
        .json::<ApiResponse<Vec<Tunnel>>>()
        .await?;
    debug!("get tunnels response: {:?}", res);

    Ok(res)
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateTunnelParams {
    pub token: String,
    pub tunnelname: String,
    pub node: String,
    pub localip: String,
    #[serde(rename = "porttype")]
    pub port_type: String, // 避免字段命名风格不一致
    #[serde(rename = "localport")]
    pub local_port: u16,
    pub encryption: bool,
    pub compression: bool,
    #[serde(rename = "extraparams")]
    pub extra_params: String,
    #[serde(rename = "remoteport")]
    pub remote_port: u16,
}
/// create_tunnel
pub async fn create_tunnel(chml_api: &ChmlApi, params: &CreateTunnelParams) -> ApiResult<Tunnel> {
    let api_url = chml_api.endpoint("/create_tunnel");

    let req = chml_api.client.post(api_url).json(&params).build()?;
    debug!("create tunnel request: {:?}", req.url());

    let res = chml_api
        .client
        .execute(req)
        .await?
        .json::<ApiResponse<Tunnel>>()
        .await?;
    debug!("create tunnel response: {:?}", res);
    // 创建出的隧道 返回为啥 id 是null啊，
    Ok(res)
}

/// delete_tunnel
pub async fn delete_tunnel(chml_api: &ChmlApi, tunnel_id: &str) -> ApiResult<()> {
    let api_url = chml_api.endpoint("/delete_tunnel");

    let req = chml_api
        .client
        .post(api_url)
        .query(&[("token", chml_api.get_token()?), ("tunnelid", tunnel_id)])
        .build()?;
    debug!("delete tunnel request: {:?}", req.url());

    let res = chml_api
        .client
        .execute(req)
        .await?
        .json::<ApiResponse<()>>()
        .await?;
    debug!("delete tunnel response: {:?}", res);

    Ok(res)
}

/// update_tunnel
pub async fn update_tunnel(chml_api: &ChmlApi, tunnel_update: TunnelUpdate) -> ApiResult<Tunnel> {
    let api_url = chml_api.endpoint("/update_tunnel");

    let req = chml_api
        .client
        .post(api_url)
        .header("Authorization", format!("Bearer {}", chml_api.get_token()?))
        .json(&tunnel_update)
        .build()?;
    debug!("update tunnel config request: {:?}", req.url());

    let res = chml_api
        .client
        .execute(req)
        .await?
        .json::<ApiResponse<Tunnel>>()
        .await?;
    debug!("update tunnel config response: {:?}", res);

    Ok(res)
}

/// 这里怎么又用Bearer了， 能统一一下认证方式吗？
/// get_tunnel_config
pub async fn get_tunnel_config(
    chml_api: &ChmlApi,
    node: &str,
    tunnel_names: &[&str],
) -> ApiResult<String> {
    let api_url = chml_api.endpoint("/tunnel_config");

    let req = chml_api
        .client
        .get(api_url)
        .header("Authorization", format!("Bearer {}", chml_api.get_token()?))
        .query(&[
            ("node", node),
            ("tunnel_names", tunnel_names.join(",").as_str()),
        ])
        .build()?;
    debug!("get tunnel config request: {:?}", req.url());

    let res = chml_api
        .client
        .execute(req)
        .await?
        .json::<ApiResponse<String>>()
        .await?;
    debug!("get tunnel config response: {:?}", res);

    Ok(res)
}