1use reqwest;
13
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum BrokersBaseBacklogQuotaCheckError {
22 Status403(),
23 Status500(),
24 UnknownValue(serde_json::Value),
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(untagged)]
30pub enum BrokersBaseDeleteDynamicConfigurationError {
31 Status403(),
32 Status412(),
33 Status500(),
34 UnknownValue(serde_json::Value),
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum BrokersBaseGetActiveBrokersError {
41 Status401(),
42 Status403(),
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum BrokersBaseGetActiveBrokers0Error {
50 Status401(),
51 Status403(),
52 Status404(),
53 UnknownValue(serde_json::Value),
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
58#[serde(untagged)]
59pub enum BrokersBaseGetAllDynamicConfigurationsError {
60 Status403(),
61 Status404(),
62 Status500(),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum BrokersBaseGetDynamicConfigurationNameError {
70 Status403(),
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum BrokersBaseGetInternalConfigurationDataError {
78 Status403(),
79 UnknownValue(serde_json::Value),
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum BrokersBaseGetLeaderBrokerError {
86 Status401(),
87 Status403(),
88 Status404(),
89 UnknownValue(serde_json::Value),
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
94#[serde(untagged)]
95pub enum BrokersBaseGetOwnedNamespacesError {
96 Status403(),
97 Status404(),
98 UnknownValue(serde_json::Value),
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum BrokersBaseGetRuntimeConfigurationError {
105 Status403(),
106 UnknownValue(serde_json::Value),
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum BrokersBaseHealthCheckError {
113 Status403(),
114 Status404(),
115 Status500(),
116 UnknownValue(serde_json::Value),
117}
118
119#[derive(Debug, Clone, Serialize, Deserialize)]
121#[serde(untagged)]
122pub enum BrokersBaseIsReadyError {
123 Status500(),
124 UnknownValue(serde_json::Value),
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(untagged)]
130pub enum BrokersBaseShutDownBrokerGracefullyError {
131 Status403(),
132 Status500(),
133 UnknownValue(serde_json::Value),
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(untagged)]
139pub enum BrokersBaseUpdateDynamicConfigurationError {
140 Status403(),
141 Status404(),
142 Status412(),
143 Status500(),
144 UnknownValue(serde_json::Value),
145}
146
147#[derive(Debug, Clone, Serialize, Deserialize)]
149#[serde(untagged)]
150pub enum BrokersBaseVersionError {
151 Status500(),
152 UnknownValue(serde_json::Value),
153}
154
155
156pub async fn brokers_base_backlog_quota_check(configuration: &configuration::Configuration, ) -> Result<(), Error<BrokersBaseBacklogQuotaCheckError>> {
157 let local_var_configuration = configuration;
158
159 let local_var_client = &local_var_configuration.client;
160
161 let local_var_uri_str = format!("{}/brokers/backlog-quota-check", local_var_configuration.base_path);
162 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
163
164 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
165 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
166 }
167 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
168 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
169 };
170
171 let local_var_req = local_var_req_builder.build()?;
172 let local_var_resp = local_var_client.execute(local_var_req).await?;
173
174 let local_var_status = local_var_resp.status();
175 let local_var_content = local_var_resp.text().await?;
176
177 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
178 Ok(())
179 } else {
180 let local_var_entity: Option<BrokersBaseBacklogQuotaCheckError> = serde_json::from_str(&local_var_content).ok();
181 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
182 Err(Error::ResponseError(local_var_error))
183 }
184}
185
186pub async fn brokers_base_delete_dynamic_configuration(configuration: &configuration::Configuration, config_name: &str) -> Result<(), Error<BrokersBaseDeleteDynamicConfigurationError>> {
187 let local_var_configuration = configuration;
188
189 let local_var_client = &local_var_configuration.client;
190
191 let local_var_uri_str = format!("{}/brokers/configuration/{configName}", local_var_configuration.base_path, configName=crate::apis::urlencode(config_name));
192 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
193
194 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
195 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
196 }
197 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
198 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
199 };
200
201 let local_var_req = local_var_req_builder.build()?;
202 let local_var_resp = local_var_client.execute(local_var_req).await?;
203
204 let local_var_status = local_var_resp.status();
205 let local_var_content = local_var_resp.text().await?;
206
207 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
208 Ok(())
209 } else {
210 let local_var_entity: Option<BrokersBaseDeleteDynamicConfigurationError> = serde_json::from_str(&local_var_content).ok();
211 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
212 Err(Error::ResponseError(local_var_error))
213 }
214}
215
216pub async fn brokers_base_get_active_brokers(configuration: &configuration::Configuration, ) -> Result<Vec<String>, Error<BrokersBaseGetActiveBrokersError>> {
217 let local_var_configuration = configuration;
218
219 let local_var_client = &local_var_configuration.client;
220
221 let local_var_uri_str = format!("{}/brokers", local_var_configuration.base_path);
222 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
223
224 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
225 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
226 }
227 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
228 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
229 };
230
231 let local_var_req = local_var_req_builder.build()?;
232 let local_var_resp = local_var_client.execute(local_var_req).await?;
233
234 let local_var_status = local_var_resp.status();
235 let local_var_content = local_var_resp.text().await?;
236
237 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
238 serde_json::from_str(&local_var_content).map_err(Error::from)
239 } else {
240 let local_var_entity: Option<BrokersBaseGetActiveBrokersError> = serde_json::from_str(&local_var_content).ok();
241 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
242 Err(Error::ResponseError(local_var_error))
243 }
244}
245
246pub async fn brokers_base_get_active_brokers_0(configuration: &configuration::Configuration, cluster: &str) -> Result<Vec<String>, Error<BrokersBaseGetActiveBrokers0Error>> {
247 let local_var_configuration = configuration;
248
249 let local_var_client = &local_var_configuration.client;
250
251 let local_var_uri_str = format!("{}/brokers/{cluster}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
252 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
253
254 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
255 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
256 }
257 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
258 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
259 };
260
261 let local_var_req = local_var_req_builder.build()?;
262 let local_var_resp = local_var_client.execute(local_var_req).await?;
263
264 let local_var_status = local_var_resp.status();
265 let local_var_content = local_var_resp.text().await?;
266
267 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
268 serde_json::from_str(&local_var_content).map_err(Error::from)
269 } else {
270 let local_var_entity: Option<BrokersBaseGetActiveBrokers0Error> = serde_json::from_str(&local_var_content).ok();
271 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
272 Err(Error::ResponseError(local_var_error))
273 }
274}
275
276pub async fn brokers_base_get_all_dynamic_configurations(configuration: &configuration::Configuration, ) -> Result<(), Error<BrokersBaseGetAllDynamicConfigurationsError>> {
277 let local_var_configuration = configuration;
278
279 let local_var_client = &local_var_configuration.client;
280
281 let local_var_uri_str = format!("{}/brokers/configuration/values", local_var_configuration.base_path);
282 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
283
284 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
285 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
286 }
287 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
288 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
289 };
290
291 let local_var_req = local_var_req_builder.build()?;
292 let local_var_resp = local_var_client.execute(local_var_req).await?;
293
294 let local_var_status = local_var_resp.status();
295 let local_var_content = local_var_resp.text().await?;
296
297 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
298 Ok(())
299 } else {
300 let local_var_entity: Option<BrokersBaseGetAllDynamicConfigurationsError> = serde_json::from_str(&local_var_content).ok();
301 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
302 Err(Error::ResponseError(local_var_error))
303 }
304}
305
306pub async fn brokers_base_get_dynamic_configuration_name(configuration: &configuration::Configuration, ) -> Result<(), Error<BrokersBaseGetDynamicConfigurationNameError>> {
307 let local_var_configuration = configuration;
308
309 let local_var_client = &local_var_configuration.client;
310
311 let local_var_uri_str = format!("{}/brokers/configuration", local_var_configuration.base_path);
312 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
313
314 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
315 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
316 }
317 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
318 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
319 };
320
321 let local_var_req = local_var_req_builder.build()?;
322 let local_var_resp = local_var_client.execute(local_var_req).await?;
323
324 let local_var_status = local_var_resp.status();
325 let local_var_content = local_var_resp.text().await?;
326
327 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
328 Ok(())
329 } else {
330 let local_var_entity: Option<BrokersBaseGetDynamicConfigurationNameError> = serde_json::from_str(&local_var_content).ok();
331 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
332 Err(Error::ResponseError(local_var_error))
333 }
334}
335
336pub async fn brokers_base_get_internal_configuration_data(configuration: &configuration::Configuration, ) -> Result<models::InternalConfigurationData, Error<BrokersBaseGetInternalConfigurationDataError>> {
337 let local_var_configuration = configuration;
338
339 let local_var_client = &local_var_configuration.client;
340
341 let local_var_uri_str = format!("{}/brokers/internal-configuration", local_var_configuration.base_path);
342 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
343
344 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
345 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
346 }
347 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
348 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
349 };
350
351 let local_var_req = local_var_req_builder.build()?;
352 let local_var_resp = local_var_client.execute(local_var_req).await?;
353
354 let local_var_status = local_var_resp.status();
355 let local_var_content = local_var_resp.text().await?;
356
357 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
358 serde_json::from_str(&local_var_content).map_err(Error::from)
359 } else {
360 let local_var_entity: Option<BrokersBaseGetInternalConfigurationDataError> = serde_json::from_str(&local_var_content).ok();
361 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
362 Err(Error::ResponseError(local_var_error))
363 }
364}
365
366pub async fn brokers_base_get_leader_broker(configuration: &configuration::Configuration, ) -> Result<models::BrokerInfo, Error<BrokersBaseGetLeaderBrokerError>> {
367 let local_var_configuration = configuration;
368
369 let local_var_client = &local_var_configuration.client;
370
371 let local_var_uri_str = format!("{}/brokers/leaderBroker", local_var_configuration.base_path);
372 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
373
374 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
375 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
376 }
377 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
378 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
379 };
380
381 let local_var_req = local_var_req_builder.build()?;
382 let local_var_resp = local_var_client.execute(local_var_req).await?;
383
384 let local_var_status = local_var_resp.status();
385 let local_var_content = local_var_resp.text().await?;
386
387 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
388 serde_json::from_str(&local_var_content).map_err(Error::from)
389 } else {
390 let local_var_entity: Option<BrokersBaseGetLeaderBrokerError> = serde_json::from_str(&local_var_content).ok();
391 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
392 Err(Error::ResponseError(local_var_error))
393 }
394}
395
396pub async fn brokers_base_get_owned_namespaces(configuration: &configuration::Configuration, cluster_name: &str, broker_id: &str) -> Result<std::collections::HashMap<String, models::NamespaceOwnershipStatus>, Error<BrokersBaseGetOwnedNamespacesError>> {
397 let local_var_configuration = configuration;
398
399 let local_var_client = &local_var_configuration.client;
400
401 let local_var_uri_str = format!("{}/brokers/{clusterName}/{brokerId}/ownedNamespaces", local_var_configuration.base_path, clusterName=crate::apis::urlencode(cluster_name), brokerId=crate::apis::urlencode(broker_id));
402 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
403
404 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
405 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
406 }
407 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
408 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
409 };
410
411 let local_var_req = local_var_req_builder.build()?;
412 let local_var_resp = local_var_client.execute(local_var_req).await?;
413
414 let local_var_status = local_var_resp.status();
415 let local_var_content = local_var_resp.text().await?;
416
417 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
418 serde_json::from_str(&local_var_content).map_err(Error::from)
419 } else {
420 let local_var_entity: Option<BrokersBaseGetOwnedNamespacesError> = serde_json::from_str(&local_var_content).ok();
421 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
422 Err(Error::ResponseError(local_var_error))
423 }
424}
425
426pub async fn brokers_base_get_runtime_configuration(configuration: &configuration::Configuration, ) -> Result<(), Error<BrokersBaseGetRuntimeConfigurationError>> {
427 let local_var_configuration = configuration;
428
429 let local_var_client = &local_var_configuration.client;
430
431 let local_var_uri_str = format!("{}/brokers/configuration/runtime", local_var_configuration.base_path);
432 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
433
434 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
435 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
436 }
437 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
438 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
439 };
440
441 let local_var_req = local_var_req_builder.build()?;
442 let local_var_resp = local_var_client.execute(local_var_req).await?;
443
444 let local_var_status = local_var_resp.status();
445 let local_var_content = local_var_resp.text().await?;
446
447 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
448 Ok(())
449 } else {
450 let local_var_entity: Option<BrokersBaseGetRuntimeConfigurationError> = serde_json::from_str(&local_var_content).ok();
451 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
452 Err(Error::ResponseError(local_var_error))
453 }
454}
455
456pub async fn brokers_base_health_check(configuration: &configuration::Configuration, topic_version: Option<&str>) -> Result<(), Error<BrokersBaseHealthCheckError>> {
457 let local_var_configuration = configuration;
458
459 let local_var_client = &local_var_configuration.client;
460
461 let local_var_uri_str = format!("{}/brokers/health", local_var_configuration.base_path);
462 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
463
464 if let Some(ref local_var_str) = topic_version {
465 local_var_req_builder = local_var_req_builder.query(&[("topicVersion", &local_var_str.to_string())]);
466 }
467 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
468 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
469 }
470 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
471 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
472 };
473
474 let local_var_req = local_var_req_builder.build()?;
475 let local_var_resp = local_var_client.execute(local_var_req).await?;
476
477 let local_var_status = local_var_resp.status();
478 let local_var_content = local_var_resp.text().await?;
479
480 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
481 Ok(())
482 } else {
483 let local_var_entity: Option<BrokersBaseHealthCheckError> = serde_json::from_str(&local_var_content).ok();
484 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
485 Err(Error::ResponseError(local_var_error))
486 }
487}
488
489pub async fn brokers_base_is_ready(configuration: &configuration::Configuration, ) -> Result<(), Error<BrokersBaseIsReadyError>> {
490 let local_var_configuration = configuration;
491
492 let local_var_client = &local_var_configuration.client;
493
494 let local_var_uri_str = format!("{}/brokers/ready", local_var_configuration.base_path);
495 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
496
497 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
498 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
499 }
500 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
501 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
502 };
503
504 let local_var_req = local_var_req_builder.build()?;
505 let local_var_resp = local_var_client.execute(local_var_req).await?;
506
507 let local_var_status = local_var_resp.status();
508 let local_var_content = local_var_resp.text().await?;
509
510 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
511 Ok(())
512 } else {
513 let local_var_entity: Option<BrokersBaseIsReadyError> = serde_json::from_str(&local_var_content).ok();
514 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
515 Err(Error::ResponseError(local_var_error))
516 }
517}
518
519pub async fn brokers_base_shut_down_broker_gracefully(configuration: &configuration::Configuration, max_concurrent_unload_per_sec: Option<i32>, forced_terminate_topic: Option<bool>) -> Result<(), Error<BrokersBaseShutDownBrokerGracefullyError>> {
520 let local_var_configuration = configuration;
521
522 let local_var_client = &local_var_configuration.client;
523
524 let local_var_uri_str = format!("{}/brokers/shutdown", local_var_configuration.base_path);
525 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
526
527 if let Some(ref local_var_str) = max_concurrent_unload_per_sec {
528 local_var_req_builder = local_var_req_builder.query(&[("maxConcurrentUnloadPerSec", &local_var_str.to_string())]);
529 }
530 if let Some(ref local_var_str) = forced_terminate_topic {
531 local_var_req_builder = local_var_req_builder.query(&[("forcedTerminateTopic", &local_var_str.to_string())]);
532 }
533 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
534 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
535 }
536 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
537 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
538 };
539
540 let local_var_req = local_var_req_builder.build()?;
541 let local_var_resp = local_var_client.execute(local_var_req).await?;
542
543 let local_var_status = local_var_resp.status();
544 let local_var_content = local_var_resp.text().await?;
545
546 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
547 Ok(())
548 } else {
549 let local_var_entity: Option<BrokersBaseShutDownBrokerGracefullyError> = serde_json::from_str(&local_var_content).ok();
550 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
551 Err(Error::ResponseError(local_var_error))
552 }
553}
554
555pub async fn brokers_base_update_dynamic_configuration(configuration: &configuration::Configuration, config_name: &str, config_value: &str) -> Result<(), Error<BrokersBaseUpdateDynamicConfigurationError>> {
556 let local_var_configuration = configuration;
557
558 let local_var_client = &local_var_configuration.client;
559
560 let local_var_uri_str = format!("{}/brokers/configuration/{configName}/{configValue}", local_var_configuration.base_path, configName=crate::apis::urlencode(config_name), configValue=crate::apis::urlencode(config_value));
561 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
562
563 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
564 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
565 }
566 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
567 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
568 };
569
570 let local_var_req = local_var_req_builder.build()?;
571 let local_var_resp = local_var_client.execute(local_var_req).await?;
572
573 let local_var_status = local_var_resp.status();
574 let local_var_content = local_var_resp.text().await?;
575
576 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
577 Ok(())
578 } else {
579 let local_var_entity: Option<BrokersBaseUpdateDynamicConfigurationError> = serde_json::from_str(&local_var_content).ok();
580 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
581 Err(Error::ResponseError(local_var_error))
582 }
583}
584
585pub async fn brokers_base_version(configuration: &configuration::Configuration, ) -> Result<String, Error<BrokersBaseVersionError>> {
586 let local_var_configuration = configuration;
587
588 let local_var_client = &local_var_configuration.client;
589
590 let local_var_uri_str = format!("{}/brokers/version", local_var_configuration.base_path);
591 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
592
593 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
594 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
595 }
596 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
597 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
598 };
599
600 let local_var_req = local_var_req_builder.build()?;
601 let local_var_resp = local_var_client.execute(local_var_req).await?;
602
603 let local_var_status = local_var_resp.status();
604 let local_var_content = local_var_resp.text().await?;
605
606 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
607 serde_json::from_str(&local_var_content).map_err(Error::from)
608 } else {
609 let local_var_entity: Option<BrokersBaseVersionError> = serde_json::from_str(&local_var_content).ok();
610 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
611 Err(Error::ResponseError(local_var_error))
612 }
613}
614