tencent_sdk/transport/
mod.rs

1use crate::core::TencentCloudError;
2use http::{Method, StatusCode};
3use std::{collections::HashMap, time::Duration};
4use url::Url;
5
6pub mod async_impl {
7    use super::*;
8    use async_trait::async_trait;
9    use reqwest::Client;
10
11    #[async_trait]
12    pub trait AsyncTransport: Clone + Send + Sync + 'static {
13        async fn send(
14            &self,
15            method: Method,
16            url: Url,
17            headers: HashMap<String, String>,
18            body: Option<String>,
19            timeout: Duration,
20        ) -> Result<(StatusCode, String), TencentCloudError>;
21    }
22
23    #[derive(Clone)]
24    pub struct ReqwestAsync {
25        client: Client,
26    }
27
28    impl ReqwestAsync {
29        pub fn new(
30            insecure: bool,
31            ua: &str,
32            timeout: Duration,
33            no_proxy: bool,
34        ) -> Result<Self, reqwest::Error> {
35            let mut builder = Client::builder()
36                .danger_accept_invalid_certs(insecure)
37                .user_agent(ua)
38                .timeout(timeout);
39
40            if no_proxy {
41                builder = builder.no_proxy();
42            }
43
44            let client = builder.build()?;
45            Ok(Self { client })
46        }
47    }
48
49    #[async_trait]
50    impl AsyncTransport for ReqwestAsync {
51        async fn send(
52            &self,
53            method: Method,
54            url: Url,
55            headers: HashMap<String, String>,
56            body: Option<String>,
57            timeout: Duration,
58        ) -> Result<(StatusCode, String), TencentCloudError> {
59            let mut req = self
60                .client
61                .request(method.clone(), url.clone())
62                .timeout(timeout);
63
64            for (key, value) in &headers {
65                req = req.header(key, value);
66            }
67            if let Some(body) = &body {
68                req = req.body(body.clone());
69            }
70
71            let response = req.send().await.map_err(|source| {
72                TencentCloudError::transport(source, method.clone(), url.clone())
73            })?;
74
75            let status = response.status();
76            let body = response.text().await.map_err(|source| {
77                TencentCloudError::transport(source, method.clone(), url.clone())
78            })?;
79            Ok((status, body))
80        }
81    }
82
83    pub type DefaultAsyncTransport = ReqwestAsync;
84}
85
86pub mod blocking_impl {
87    use super::*;
88    use reqwest::blocking::Client;
89
90    pub trait BlockingTransport: Clone + Send + Sync + 'static {
91        fn send(
92            &self,
93            method: Method,
94            url: Url,
95            headers: HashMap<String, String>,
96            body: Option<String>,
97            timeout: Duration,
98        ) -> Result<(StatusCode, String), TencentCloudError>;
99    }
100
101    #[derive(Clone)]
102    pub struct ReqwestBlocking {
103        client: Client,
104    }
105
106    impl ReqwestBlocking {
107        pub fn new(
108            insecure: bool,
109            ua: &str,
110            timeout: Duration,
111            no_proxy: bool,
112        ) -> Result<Self, reqwest::Error> {
113            let mut builder = Client::builder()
114                .danger_accept_invalid_certs(insecure)
115                .user_agent(ua)
116                .timeout(timeout);
117
118            if no_proxy {
119                builder = builder.no_proxy();
120            }
121
122            let client = builder.build()?;
123            Ok(Self { client })
124        }
125    }
126
127    impl BlockingTransport for ReqwestBlocking {
128        fn send(
129            &self,
130            method: Method,
131            url: Url,
132            headers: HashMap<String, String>,
133            body: Option<String>,
134            timeout: Duration,
135        ) -> Result<(StatusCode, String), TencentCloudError> {
136            let mut req = self
137                .client
138                .request(method.clone(), url.clone())
139                .timeout(timeout);
140
141            for (key, value) in &headers {
142                req = req.header(key, value);
143            }
144            if let Some(body) = &body {
145                req = req.body(body.clone());
146            }
147
148            let response = req.send().map_err(|source| {
149                TencentCloudError::transport(source, method.clone(), url.clone())
150            })?;
151
152            let status = response.status();
153            let body = response
154                .text()
155                .map_err(|source| TencentCloudError::transport(source, method, url))?;
156            Ok((status, body))
157        }
158    }
159
160    pub type DefaultBlockingTransport = ReqwestBlocking;
161}
tencent_sdk/transport/mod.rs

tencent_sdk/transport/
mod.rs
