1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum ForceLeaveError {
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum GetHealthError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum GetMembersError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum GetSelfError {
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum GetServersError {
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum JoinError {
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum StreamLogsError {
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum UpdateServersError {
71 UnknownValue(serde_json::Value),
72}
73
74
75pub async fn force_leave(configuration: &configuration::Configuration, node: &str, namespace: Option<&str>, region: Option<&str>, index: Option<i64>, wait: Option<&str>) -> Result<(), Error<ForceLeaveError>> {
76
77 let local_var_client = &configuration.client;
78
79 let local_var_uri_str = format!("{}/agent/force-leave", configuration.base_path);
80 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
81
82 if let Some(ref local_var_str) = namespace {
83 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
84 }
85 if let Some(ref local_var_str) = region {
86 local_var_req_builder = local_var_req_builder.query(&[("region", &local_var_str.to_string())]);
87 }
88 if let Some(ref local_var_str) = index {
89 local_var_req_builder = local_var_req_builder.query(&[("index", &local_var_str.to_string())]);
90 }
91 if let Some(ref local_var_str) = wait {
92 local_var_req_builder = local_var_req_builder.query(&[("wait", &local_var_str.to_string())]);
93 }
94 local_var_req_builder = local_var_req_builder.query(&[("node", &node.to_string())]);
95 if let Some(ref local_var_user_agent) = configuration.user_agent {
96 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
97 }
98
99 let local_var_req = local_var_req_builder.build()?;
100 let local_var_resp = local_var_client.execute(local_var_req).await?;
101
102 let local_var_status = local_var_resp.status();
103 let local_var_content = local_var_resp.text().await?;
104
105 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
106 Ok(())
107 } else {
108 let local_var_entity: Option<ForceLeaveError> = serde_json::from_str(&local_var_content).ok();
109 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
110 Err(Error::ResponseError(local_var_error))
111 }
112}
113
114pub async fn get_health(configuration: &configuration::Configuration, namespace: Option<&str>, region: Option<&str>, index: Option<i64>, wait: Option<&str>) -> Result<crate::models::AgentHealthResponse, Error<GetHealthError>> {
115
116 let local_var_client = &configuration.client;
117
118 let local_var_uri_str = format!("{}/agent/health", configuration.base_path);
119 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
120
121 if let Some(ref local_var_str) = namespace {
122 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
123 }
124 if let Some(ref local_var_str) = region {
125 local_var_req_builder = local_var_req_builder.query(&[("region", &local_var_str.to_string())]);
126 }
127 if let Some(ref local_var_str) = index {
128 local_var_req_builder = local_var_req_builder.query(&[("index", &local_var_str.to_string())]);
129 }
130 if let Some(ref local_var_str) = wait {
131 local_var_req_builder = local_var_req_builder.query(&[("wait", &local_var_str.to_string())]);
132 }
133 if let Some(ref local_var_user_agent) = configuration.user_agent {
134 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
135 }
136
137 let local_var_req = local_var_req_builder.build()?;
138 let local_var_resp = local_var_client.execute(local_var_req).await?;
139
140 let local_var_status = local_var_resp.status();
141 let local_var_content = local_var_resp.text().await?;
142
143 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
144 serde_json::from_str(&local_var_content).map_err(Error::from)
145 } else {
146 let local_var_entity: Option<GetHealthError> = serde_json::from_str(&local_var_content).ok();
147 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
148 Err(Error::ResponseError(local_var_error))
149 }
150}
151
152pub async fn get_members(configuration: &configuration::Configuration, namespace: Option<&str>, region: Option<&str>, index: Option<i64>, wait: Option<&str>) -> Result<crate::models::ServerMembers, Error<GetMembersError>> {
153
154 let local_var_client = &configuration.client;
155
156 let local_var_uri_str = format!("{}/agent/members", configuration.base_path);
157 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
158
159 if let Some(ref local_var_str) = namespace {
160 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
161 }
162 if let Some(ref local_var_str) = region {
163 local_var_req_builder = local_var_req_builder.query(&[("region", &local_var_str.to_string())]);
164 }
165 if let Some(ref local_var_str) = index {
166 local_var_req_builder = local_var_req_builder.query(&[("index", &local_var_str.to_string())]);
167 }
168 if let Some(ref local_var_str) = wait {
169 local_var_req_builder = local_var_req_builder.query(&[("wait", &local_var_str.to_string())]);
170 }
171 if let Some(ref local_var_user_agent) = configuration.user_agent {
172 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
173 }
174
175 let local_var_req = local_var_req_builder.build()?;
176 let local_var_resp = local_var_client.execute(local_var_req).await?;
177
178 let local_var_status = local_var_resp.status();
179 let local_var_content = local_var_resp.text().await?;
180
181 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
182 serde_json::from_str(&local_var_content).map_err(Error::from)
183 } else {
184 let local_var_entity: Option<GetMembersError> = serde_json::from_str(&local_var_content).ok();
185 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
186 Err(Error::ResponseError(local_var_error))
187 }
188}
189
190pub async fn get_self(configuration: &configuration::Configuration, namespace: Option<&str>, region: Option<&str>, index: Option<i64>, wait: Option<&str>) -> Result<crate::models::AgentSelf, Error<GetSelfError>> {
191
192 let local_var_client = &configuration.client;
193
194 let local_var_uri_str = format!("{}/agent/self", configuration.base_path);
195 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
196
197 if let Some(ref local_var_str) = namespace {
198 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
199 }
200 if let Some(ref local_var_str) = region {
201 local_var_req_builder = local_var_req_builder.query(&[("region", &local_var_str.to_string())]);
202 }
203 if let Some(ref local_var_str) = index {
204 local_var_req_builder = local_var_req_builder.query(&[("index", &local_var_str.to_string())]);
205 }
206 if let Some(ref local_var_str) = wait {
207 local_var_req_builder = local_var_req_builder.query(&[("wait", &local_var_str.to_string())]);
208 }
209 if let Some(ref local_var_user_agent) = configuration.user_agent {
210 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
211 }
212
213 let local_var_req = local_var_req_builder.build()?;
214 let local_var_resp = local_var_client.execute(local_var_req).await?;
215
216 let local_var_status = local_var_resp.status();
217 let local_var_content = local_var_resp.text().await?;
218
219 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
220 serde_json::from_str(&local_var_content).map_err(Error::from)
221 } else {
222 let local_var_entity: Option<GetSelfError> = serde_json::from_str(&local_var_content).ok();
223 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
224 Err(Error::ResponseError(local_var_error))
225 }
226}
227
228pub async fn get_servers(configuration: &configuration::Configuration, ) -> Result<Vec<String>, Error<GetServersError>> {
229
230 let local_var_client = &configuration.client;
231
232 let local_var_uri_str = format!("{}/agent/servers", configuration.base_path);
233 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
234
235 if let Some(ref local_var_user_agent) = configuration.user_agent {
236 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
237 }
238
239 let local_var_req = local_var_req_builder.build()?;
240 let local_var_resp = local_var_client.execute(local_var_req).await?;
241
242 let local_var_status = local_var_resp.status();
243 let local_var_content = local_var_resp.text().await?;
244
245 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
246 serde_json::from_str(&local_var_content).map_err(Error::from)
247 } else {
248 let local_var_entity: Option<GetServersError> = serde_json::from_str(&local_var_content).ok();
249 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
250 Err(Error::ResponseError(local_var_error))
251 }
252}
253
254pub async fn join(configuration: &configuration::Configuration, address: Vec<String>, namespace: Option<&str>, region: Option<&str>, index: Option<i64>, wait: Option<&str>) -> Result<crate::models::JoinResponse, Error<JoinError>> {
255
256 let local_var_client = &configuration.client;
257
258 let local_var_uri_str = format!("{}/agent/join", configuration.base_path);
259 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
260
261 if let Some(ref local_var_str) = namespace {
262 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
263 }
264 if let Some(ref local_var_str) = region {
265 local_var_req_builder = local_var_req_builder.query(&[("region", &local_var_str.to_string())]);
266 }
267 if let Some(ref local_var_str) = index {
268 local_var_req_builder = local_var_req_builder.query(&[("index", &local_var_str.to_string())]);
269 }
270 if let Some(ref local_var_str) = wait {
271 local_var_req_builder = local_var_req_builder.query(&[("wait", &local_var_str.to_string())]);
272 }
273 local_var_req_builder = local_var_req_builder.query(&[("address", &address.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
274 if let Some(ref local_var_user_agent) = configuration.user_agent {
275 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
276 }
277
278 let local_var_req = local_var_req_builder.build()?;
279 let local_var_resp = local_var_client.execute(local_var_req).await?;
280
281 let local_var_status = local_var_resp.status();
282 let local_var_content = local_var_resp.text().await?;
283
284 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
285 serde_json::from_str(&local_var_content).map_err(Error::from)
286 } else {
287 let local_var_entity: Option<JoinError> = serde_json::from_str(&local_var_content).ok();
288 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
289 Err(Error::ResponseError(local_var_error))
290 }
291}
292
293pub async fn stream_logs(configuration: &configuration::Configuration, namespace: Option<&str>, region: Option<&str>, index: Option<i64>, wait: Option<&str>, log_level: Option<&str>, node_id: Option<&str>, server_id: Option<&str>, json: Option<bool>, plain: Option<bool>) -> Result<crate::models::StreamFrame, Error<StreamLogsError>> {
294
295 let local_var_client = &configuration.client;
296
297 let local_var_uri_str = format!("{}/agent/monitor", configuration.base_path);
298 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
299
300 if let Some(ref local_var_str) = namespace {
301 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
302 }
303 if let Some(ref local_var_str) = region {
304 local_var_req_builder = local_var_req_builder.query(&[("region", &local_var_str.to_string())]);
305 }
306 if let Some(ref local_var_str) = index {
307 local_var_req_builder = local_var_req_builder.query(&[("index", &local_var_str.to_string())]);
308 }
309 if let Some(ref local_var_str) = wait {
310 local_var_req_builder = local_var_req_builder.query(&[("wait", &local_var_str.to_string())]);
311 }
312 if let Some(ref local_var_str) = log_level {
313 local_var_req_builder = local_var_req_builder.query(&[("log_level", &local_var_str.to_string())]);
314 }
315 if let Some(ref local_var_str) = node_id {
316 local_var_req_builder = local_var_req_builder.query(&[("node_id", &local_var_str.to_string())]);
317 }
318 if let Some(ref local_var_str) = server_id {
319 local_var_req_builder = local_var_req_builder.query(&[("server_id", &local_var_str.to_string())]);
320 }
321 if let Some(ref local_var_str) = json {
322 local_var_req_builder = local_var_req_builder.query(&[("json", &local_var_str.to_string())]);
323 }
324 if let Some(ref local_var_str) = plain {
325 local_var_req_builder = local_var_req_builder.query(&[("plain", &local_var_str.to_string())]);
326 }
327 if let Some(ref local_var_user_agent) = configuration.user_agent {
328 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
329 }
330
331 let local_var_req = local_var_req_builder.build()?;
332 let local_var_resp = local_var_client.execute(local_var_req).await?;
333
334 let local_var_status = local_var_resp.status();
335 let local_var_content = local_var_resp.text().await?;
336
337 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
338 serde_json::from_str(&local_var_content).map_err(Error::from)
339 } else {
340 let local_var_entity: Option<StreamLogsError> = serde_json::from_str(&local_var_content).ok();
341 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
342 Err(Error::ResponseError(local_var_error))
343 }
344}
345
346pub async fn update_servers(configuration: &configuration::Configuration, address: Vec<String>, namespace: Option<&str>, region: Option<&str>, index: Option<i64>, wait: Option<&str>) -> Result<Vec<String>, Error<UpdateServersError>> {
347
348 let local_var_client = &configuration.client;
349
350 let local_var_uri_str = format!("{}/agent/servers", configuration.base_path);
351 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
352
353 if let Some(ref local_var_str) = namespace {
354 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
355 }
356 if let Some(ref local_var_str) = region {
357 local_var_req_builder = local_var_req_builder.query(&[("region", &local_var_str.to_string())]);
358 }
359 if let Some(ref local_var_str) = index {
360 local_var_req_builder = local_var_req_builder.query(&[("index", &local_var_str.to_string())]);
361 }
362 if let Some(ref local_var_str) = wait {
363 local_var_req_builder = local_var_req_builder.query(&[("wait", &local_var_str.to_string())]);
364 }
365 local_var_req_builder = local_var_req_builder.query(&[("address", &address.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
366 if let Some(ref local_var_user_agent) = configuration.user_agent {
367 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
368 }
369
370 let local_var_req = local_var_req_builder.build()?;
371 let local_var_resp = local_var_client.execute(local_var_req).await?;
372
373 let local_var_status = local_var_resp.status();
374 let local_var_content = local_var_resp.text().await?;
375
376 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
377 serde_json::from_str(&local_var_content).map_err(Error::from)
378 } else {
379 let local_var_entity: Option<UpdateServersError> = serde_json::from_str(&local_var_content).ok();
380 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
381 Err(Error::ResponseError(local_var_error))
382 }
383}
384