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
use crate::errors::AivenError;
use log::debug;
use percent_encoding::{percent_encode, NON_ALPHANUMERIC};
use reqwest;
#[derive(Debug, Clone)]
pub struct HTTPClient {
client: reqwest::Client,
base_url: reqwest::Url,
version: String,
}
pub(crate) fn encode_param(param: &str) -> String {
percent_encode(param.as_bytes(), NON_ALPHANUMERIC).to_string()
}
#[macro_export]
macro_rules! make_json_request {
($sel:ident, $method:path, $url:expr, $body:ident) => {{
use crate::errors::AivenError;
use reqwest;
let response: reqwest::Response = $sel
.http_client
.inner($method, $url)?
.json($body)
.send()
.await?;
let status_code = &response.status().as_u16();
if !(*status_code >= 200 && *status_code <= 300) {
let api_response: APIResponse = response.json().await?;
return Err(AivenError::APIResponseError {
errors: api_response.errors.unwrap(),
message: api_response.message.unwrap(),
});
}
let ret: Result<reqwest::Response, AivenError> = Ok(response);
ret
}};
}
#[macro_export]
macro_rules! make_request {
($sel:ident, $method:path, $url:expr) => {{
use log::debug;
use reqwest;
let response: reqwest::Response = $sel.http_client.inner($method, $url)?.send().await?;
let status_code = &response.status().as_u16();
debug!("Received status code: {}", status_code);
if !(*status_code >= 200 && *status_code <= 300) {
let api_response: APIResponse = response.json().await?;
return Err(AivenError::APIResponseError {
errors: api_response.errors.unwrap(),
message: api_response.message.unwrap(),
});
}
let ret: Result<reqwest::Response, AivenError> = Ok(response);
ret
}};
}
impl HTTPClient {
pub fn new<S>(base_url: S, client: reqwest::Client, version: String) -> HTTPClient
where
S: Into<String>,
{
let parsed_url =
reqwest::Url::parse(&base_url.into()).expect("Failed to parse the base_url");
let ver = format!("{}/", version.replace("/", ""));
debug!("Version is {}", &ver);
HTTPClient {
base_url: parsed_url,
client,
version: ver,
}
}
pub(crate) fn inner(
&self,
method: reqwest::Method,
query_url: &str,
) -> Result<reqwest::RequestBuilder, AivenError> {
let qurl = query_url.trim_start_matches('/');
let url = self.base_url.join(&self.version)?.join(qurl)?;
debug!("URL is {:?}", &url);
let request_with_url_and_header: Result<reqwest::RequestBuilder, AivenError> = match method
{
reqwest::Method::GET => Ok(self.client.get(url)),
reqwest::Method::PUT => Ok(self.client.put(url)),
reqwest::Method::POST => Ok(self.client.post(url)),
reqwest::Method::DELETE => Ok(self.client.delete(url)),
_ => return Err(AivenError::UnsupportedMethod),
};
request_with_url_and_header
}
}