1use bon::bon;
11
12use crate::*;
13use reqwest;
14use serde::{de::Error as OtherError, Deserialize, Serialize};
15use std::sync::Arc;
16
17pub struct ClusterApiClient {
18 configuration: Arc<crate::Configuration>,
19}
20
21#[bon]
22impl ClusterApiClient {
23 pub fn new(configuration: Arc<crate::Configuration>) -> Self {
24 Self { configuration }
25 }
26
27 #[builder]
30 pub async fn get_settings(
31 &self,
32 cluster_manager_timeout: Option<String>,
35 master_timeout: Option<String>,
38 timeout: Option<String>,
41 error_trace: Option<bool>,
43 filter_path: Option<common::FilterPath>,
45 flat_settings: Option<bool>,
47 human: Option<bool>,
49 include_defaults: Option<bool>,
51 pretty: Option<bool>,
53 source: Option<String>,
55 ) -> Result<crate::cluster::GetSettingsResponse, Error> {
56 let local_var_configuration = &self.configuration;
57
58 let local_var_client = &local_var_configuration.client;
59
60 let local_var_uri_str = format!("{}_cluster/settings", local_var_configuration.base_path);
61 let mut local_var_req_builder =
62 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
63
64 if let Some(ref local_var_str) = source {
65 local_var_req_builder =
66 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
67 }
68 if let Some(ref local_var_str) = filter_path {
69 local_var_req_builder =
70 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
71 }
72 if let Some(ref local_var_str) = error_trace {
73 local_var_req_builder =
74 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
75 }
76 if let Some(ref local_var_str) = timeout {
77 local_var_req_builder =
78 local_var_req_builder.query(&[("timeout", &local_var_str.to_string())]);
79 }
80 if let Some(ref local_var_str) = pretty {
81 local_var_req_builder =
82 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
83 }
84 if let Some(ref local_var_str) = master_timeout {
85 local_var_req_builder =
86 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
87 }
88 if let Some(ref local_var_str) = flat_settings {
89 local_var_req_builder =
90 local_var_req_builder.query(&[("flat_settings", &local_var_str.to_string())]);
91 }
92 if let Some(ref local_var_str) = cluster_manager_timeout {
93 local_var_req_builder = local_var_req_builder
94 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
95 }
96 if let Some(ref local_var_str) = include_defaults {
97 local_var_req_builder =
98 local_var_req_builder.query(&[("include_defaults", &local_var_str.to_string())]);
99 }
100 if let Some(ref local_var_str) = human {
101 local_var_req_builder =
102 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
103 }
104
105 let local_var_req = local_var_req_builder.build()?;
106 let local_var_resp = local_var_client.execute(local_var_req).await?;
107
108 let local_var_status = local_var_resp.status();
109 let local_var_content = local_var_resp.text().await?;
110
111 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
112 serde_json::from_str(&local_var_content).map_err(Error::from)
113 } else {
114 let local_var_error = ResponseContent {
115 status: local_var_status,
116 content: local_var_content,
117 };
118 Err(Error::ApiError(local_var_error))
119 }
120 }
121 #[builder]
124 pub async fn get_decommission_awareness(
125 &self,
126 awareness_attribute_name: String,
128 error_trace: Option<bool>,
130 filter_path: Option<common::FilterPath>,
132 human: Option<bool>,
134 pretty: Option<bool>,
136 source: Option<String>,
138 ) -> Result<crate::cluster::decommission_awareness::DecommissionStatusResponse, Error> {
139 let local_var_configuration = &self.configuration;
140
141 let local_var_client = &local_var_configuration.client;
142
143 let local_var_uri_str = format!(
144 "{}_cluster/decommission/awareness/{awareness_attribute_name}/_status",
145 local_var_configuration.base_path,
146 awareness_attribute_name = awareness_attribute_name
147 );
148 let mut local_var_req_builder =
149 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
150
151 if let Some(ref local_var_str) = human {
152 local_var_req_builder =
153 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
154 }
155 if let Some(ref local_var_str) = pretty {
156 local_var_req_builder =
157 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
158 }
159 if let Some(ref local_var_str) = filter_path {
160 local_var_req_builder =
161 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
162 }
163 if let Some(ref local_var_str) = error_trace {
164 local_var_req_builder =
165 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
166 }
167 if let Some(ref local_var_str) = source {
168 local_var_req_builder =
169 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
170 }
171
172 let local_var_req = local_var_req_builder.build()?;
173 let local_var_resp = local_var_client.execute(local_var_req).await?;
174
175 let local_var_status = local_var_resp.status();
176 let local_var_content = local_var_resp.text().await?;
177
178 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
179 serde_json::from_str(&local_var_content).map_err(Error::from)
180 } else {
181 let local_var_error = ResponseContent {
182 status: local_var_status,
183 content: local_var_content,
184 };
185 Err(Error::ApiError(local_var_error))
186 }
187 }
188 #[builder]
191 pub async fn put_settings(
192 &self,
193 cluster_manager_timeout: Option<String>,
196 master_timeout: Option<String>,
199 timeout: Option<String>,
202 error_trace: Option<bool>,
204 filter_path: Option<common::FilterPath>,
206 flat_settings: Option<bool>,
208 human: Option<bool>,
210 pretty: Option<bool>,
212 source: Option<String>,
214 put_settings: cluster::PutSettings,
216 ) -> Result<crate::cluster::PutSettingsResponse, Error> {
217 let local_var_configuration = &self.configuration;
218
219 let local_var_client = &local_var_configuration.client;
220
221 let local_var_uri_str = format!("{}_cluster/settings", local_var_configuration.base_path);
222 let mut local_var_req_builder =
223 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
224
225 if let Some(ref local_var_str) = human {
226 local_var_req_builder =
227 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
228 }
229 if let Some(ref local_var_str) = pretty {
230 local_var_req_builder =
231 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
232 }
233 if let Some(ref local_var_str) = source {
234 local_var_req_builder =
235 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
236 }
237 if let Some(ref local_var_str) = timeout {
238 local_var_req_builder =
239 local_var_req_builder.query(&[("timeout", &local_var_str.to_string())]);
240 }
241 if let Some(ref local_var_str) = flat_settings {
242 local_var_req_builder =
243 local_var_req_builder.query(&[("flat_settings", &local_var_str.to_string())]);
244 }
245 if let Some(ref local_var_str) = cluster_manager_timeout {
246 local_var_req_builder = local_var_req_builder
247 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
248 }
249 if let Some(ref local_var_str) = master_timeout {
250 local_var_req_builder =
251 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
252 }
253 if let Some(ref local_var_str) = error_trace {
254 local_var_req_builder =
255 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
256 }
257 if let Some(ref local_var_str) = filter_path {
258 local_var_req_builder =
259 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
260 }
261
262 local_var_req_builder = local_var_req_builder.json(&put_settings);
263
264 let local_var_req = local_var_req_builder.build()?;
265 let local_var_resp = local_var_client.execute(local_var_req).await?;
266
267 let local_var_status = local_var_resp.status();
268 let local_var_content = local_var_resp.text().await?;
269
270 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
271 serde_json::from_str(&local_var_content).map_err(Error::from)
272 } else {
273 let local_var_error = ResponseContent {
274 status: local_var_status,
275 content: local_var_content,
276 };
277 Err(Error::ApiError(local_var_error))
278 }
279 }
280 #[builder]
283 pub async fn delete_component_template(
284 &self,
285 cluster_manager_timeout: Option<String>,
288 master_timeout: Option<String>,
291 timeout: Option<String>,
294 error_trace: Option<bool>,
296 filter_path: Option<common::FilterPath>,
298 human: Option<bool>,
300 name: String,
302 pretty: Option<bool>,
304 source: Option<String>,
306 ) -> Result<crate::common::AcknowledgedResponseBase, Error> {
307 let local_var_configuration = &self.configuration;
308
309 let local_var_client = &local_var_configuration.client;
310
311 let local_var_uri_str = format!(
312 "{}_component_template/{name}",
313 local_var_configuration.base_path,
314 name = name
315 );
316 let mut local_var_req_builder =
317 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
318
319 if let Some(ref local_var_str) = human {
320 local_var_req_builder =
321 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
322 }
323 if let Some(ref local_var_str) = filter_path {
324 local_var_req_builder =
325 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
326 }
327 if let Some(ref local_var_str) = pretty {
328 local_var_req_builder =
329 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
330 }
331 if let Some(ref local_var_str) = master_timeout {
332 local_var_req_builder =
333 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
334 }
335 if let Some(ref local_var_str) = error_trace {
336 local_var_req_builder =
337 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
338 }
339 if let Some(ref local_var_str) = cluster_manager_timeout {
340 local_var_req_builder = local_var_req_builder
341 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
342 }
343 if let Some(ref local_var_str) = source {
344 local_var_req_builder =
345 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
346 }
347 if let Some(ref local_var_str) = timeout {
348 local_var_req_builder =
349 local_var_req_builder.query(&[("timeout", &local_var_str.to_string())]);
350 }
351
352 let local_var_req = local_var_req_builder.build()?;
353 let local_var_resp = local_var_client.execute(local_var_req).await?;
354
355 let local_var_status = local_var_resp.status();
356 let local_var_content = local_var_resp.text().await?;
357
358 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
359 serde_json::from_str(&local_var_content).map_err(Error::from)
360 } else {
361 let local_var_error = ResponseContent {
362 status: local_var_status,
363 content: local_var_content,
364 };
365 Err(Error::ApiError(local_var_error))
366 }
367 }
368 #[builder]
371 pub async fn exists_component_template(
372 &self,
373 cluster_manager_timeout: Option<String>,
376 master_timeout: Option<String>,
379 error_trace: Option<bool>,
381 filter_path: Option<common::FilterPath>,
383 human: Option<bool>,
385 local: Option<bool>,
387 name: String,
389 pretty: Option<bool>,
391 source: Option<String>,
393 ) -> Result<serde_json::Value, Error> {
394 let local_var_configuration = &self.configuration;
395
396 let local_var_client = &local_var_configuration.client;
397
398 let local_var_uri_str = format!(
399 "{}_component_template/{name}",
400 local_var_configuration.base_path,
401 name = name
402 );
403 let mut local_var_req_builder =
404 local_var_client.request(reqwest::Method::HEAD, local_var_uri_str.as_str());
405
406 if let Some(ref local_var_str) = filter_path {
407 local_var_req_builder =
408 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
409 }
410 if let Some(ref local_var_str) = local {
411 local_var_req_builder =
412 local_var_req_builder.query(&[("local", &local_var_str.to_string())]);
413 }
414 if let Some(ref local_var_str) = human {
415 local_var_req_builder =
416 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
417 }
418 if let Some(ref local_var_str) = cluster_manager_timeout {
419 local_var_req_builder = local_var_req_builder
420 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
421 }
422 if let Some(ref local_var_str) = master_timeout {
423 local_var_req_builder =
424 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
425 }
426 if let Some(ref local_var_str) = pretty {
427 local_var_req_builder =
428 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
429 }
430 if let Some(ref local_var_str) = source {
431 local_var_req_builder =
432 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
433 }
434 if let Some(ref local_var_str) = error_trace {
435 local_var_req_builder =
436 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
437 }
438
439 let local_var_req = local_var_req_builder.build()?;
440 let local_var_resp = local_var_client.execute(local_var_req).await?;
441
442 let local_var_status = local_var_resp.status();
443 let local_var_content = local_var_resp.text().await?;
444
445 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
446 serde_json::from_str(&local_var_content).map_err(Error::from)
447 } else {
448 let local_var_error = ResponseContent {
449 status: local_var_status,
450 content: local_var_content,
451 };
452 Err(Error::ApiError(local_var_error))
453 }
454 }
455 #[builder]
458 pub async fn get_component_template(
459 &self,
460 cluster_manager_timeout: Option<String>,
463 master_timeout: Option<String>,
466 error_trace: Option<bool>,
468 filter_path: Option<common::FilterPath>,
470 flat_settings: Option<bool>,
472 human: Option<bool>,
474 local: Option<bool>,
476 name: String,
478 pretty: Option<bool>,
480 source: Option<String>,
482 ) -> Result<crate::cluster::GetComponentTemplateResponse, Error> {
483 let local_var_configuration = &self.configuration;
484
485 let local_var_client = &local_var_configuration.client;
486
487 let local_var_uri_str = format!(
488 "{}_component_template/{name}",
489 local_var_configuration.base_path,
490 name = name
491 );
492 let mut local_var_req_builder =
493 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
494
495 if let Some(ref local_var_str) = filter_path {
496 local_var_req_builder =
497 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
498 }
499 if let Some(ref local_var_str) = master_timeout {
500 local_var_req_builder =
501 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
502 }
503 if let Some(ref local_var_str) = local {
504 local_var_req_builder =
505 local_var_req_builder.query(&[("local", &local_var_str.to_string())]);
506 }
507 if let Some(ref local_var_str) = source {
508 local_var_req_builder =
509 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
510 }
511 if let Some(ref local_var_str) = cluster_manager_timeout {
512 local_var_req_builder = local_var_req_builder
513 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
514 }
515 if let Some(ref local_var_str) = human {
516 local_var_req_builder =
517 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
518 }
519 if let Some(ref local_var_str) = pretty {
520 local_var_req_builder =
521 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
522 }
523 if let Some(ref local_var_str) = flat_settings {
524 local_var_req_builder =
525 local_var_req_builder.query(&[("flat_settings", &local_var_str.to_string())]);
526 }
527 if let Some(ref local_var_str) = error_trace {
528 local_var_req_builder =
529 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
530 }
531
532 let local_var_req = local_var_req_builder.build()?;
533 let local_var_resp = local_var_client.execute(local_var_req).await?;
534
535 let local_var_status = local_var_resp.status();
536 let local_var_content = local_var_resp.text().await?;
537
538 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
539 serde_json::from_str(&local_var_content).map_err(Error::from)
540 } else {
541 let local_var_error = ResponseContent {
542 status: local_var_status,
543 content: local_var_content,
544 };
545 Err(Error::ApiError(local_var_error))
546 }
547 }
548 #[builder]
551 pub async fn delete_decommission_awareness(
552 &self,
553 error_trace: Option<bool>,
555 filter_path: Option<common::FilterPath>,
557 human: Option<bool>,
559 pretty: Option<bool>,
561 source: Option<String>,
563 ) -> Result<crate::common::AcknowledgedResponseBase, Error> {
564 let local_var_configuration = &self.configuration;
565
566 let local_var_client = &local_var_configuration.client;
567
568 let local_var_uri_str = format!(
569 "{}_cluster/decommission/awareness",
570 local_var_configuration.base_path
571 );
572 let mut local_var_req_builder =
573 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
574
575 if let Some(ref local_var_str) = source {
576 local_var_req_builder =
577 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
578 }
579 if let Some(ref local_var_str) = filter_path {
580 local_var_req_builder =
581 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
582 }
583 if let Some(ref local_var_str) = error_trace {
584 local_var_req_builder =
585 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
586 }
587 if let Some(ref local_var_str) = pretty {
588 local_var_req_builder =
589 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
590 }
591 if let Some(ref local_var_str) = human {
592 local_var_req_builder =
593 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
594 }
595
596 let local_var_req = local_var_req_builder.build()?;
597 let local_var_resp = local_var_client.execute(local_var_req).await?;
598
599 let local_var_status = local_var_resp.status();
600 let local_var_content = local_var_resp.text().await?;
601
602 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
603 serde_json::from_str(&local_var_content).map_err(Error::from)
604 } else {
605 let local_var_error = ResponseContent {
606 status: local_var_status,
607 content: local_var_content,
608 };
609 Err(Error::ApiError(local_var_error))
610 }
611 }
612 #[builder]
615 pub async fn get_weighted_routing(
616 &self,
617 attribute: String,
619 error_trace: Option<bool>,
621 filter_path: Option<common::FilterPath>,
623 human: Option<bool>,
625 pretty: Option<bool>,
627 source: Option<String>,
629 ) -> Result<crate::cluster::weighted_routing::WeightsResponse, Error> {
630 let local_var_configuration = &self.configuration;
631
632 let local_var_client = &local_var_configuration.client;
633
634 let local_var_uri_str = format!(
635 "{}_cluster/routing/awareness/{attribute}/weights",
636 local_var_configuration.base_path,
637 attribute = attribute
638 );
639 let mut local_var_req_builder =
640 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
641
642 if let Some(ref local_var_str) = human {
643 local_var_req_builder =
644 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
645 }
646 if let Some(ref local_var_str) = error_trace {
647 local_var_req_builder =
648 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
649 }
650 if let Some(ref local_var_str) = source {
651 local_var_req_builder =
652 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
653 }
654 if let Some(ref local_var_str) = pretty {
655 local_var_req_builder =
656 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
657 }
658 if let Some(ref local_var_str) = filter_path {
659 local_var_req_builder =
660 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
661 }
662
663 let local_var_req = local_var_req_builder.build()?;
664 let local_var_resp = local_var_client.execute(local_var_req).await?;
665
666 let local_var_status = local_var_resp.status();
667 let local_var_content = local_var_resp.text().await?;
668
669 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
670 serde_json::from_str(&local_var_content).map_err(Error::from)
671 } else {
672 let local_var_error = ResponseContent {
673 status: local_var_status,
674 content: local_var_content,
675 };
676 Err(Error::ApiError(local_var_error))
677 }
678 }
679 #[builder]
682 pub async fn delete_weighted_routing(
683 &self,
684 delete_weighted_routing: cluster::DeleteWeightedRouting,
685 error_trace: Option<bool>,
687 filter_path: Option<common::FilterPath>,
689 human: Option<bool>,
691 pretty: Option<bool>,
693 source: Option<String>,
695 ) -> Result<crate::common::AcknowledgedResponseBase, Error> {
696 let local_var_configuration = &self.configuration;
697
698 let local_var_client = &local_var_configuration.client;
699
700 let local_var_uri_str = format!(
701 "{}_cluster/routing/awareness/weights",
702 local_var_configuration.base_path
703 );
704 let mut local_var_req_builder =
705 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
706
707 if let Some(ref local_var_str) = pretty {
708 local_var_req_builder =
709 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
710 }
711 if let Some(ref local_var_str) = error_trace {
712 local_var_req_builder =
713 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
714 }
715 if let Some(ref local_var_str) = human {
716 local_var_req_builder =
717 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
718 }
719 if let Some(ref local_var_str) = source {
720 local_var_req_builder =
721 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
722 }
723 if let Some(ref local_var_str) = filter_path {
724 local_var_req_builder =
725 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
726 }
727
728 local_var_req_builder = local_var_req_builder.json(&delete_weighted_routing);
729
730 let local_var_req = local_var_req_builder.build()?;
731 let local_var_resp = local_var_client.execute(local_var_req).await?;
732
733 let local_var_status = local_var_resp.status();
734 let local_var_content = local_var_resp.text().await?;
735
736 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
737 serde_json::from_str(&local_var_content).map_err(Error::from)
738 } else {
739 let local_var_error = ResponseContent {
740 status: local_var_status,
741 content: local_var_content,
742 };
743 Err(Error::ApiError(local_var_error))
744 }
745 }
746 #[builder]
749 pub async fn post_voting_config_exclusions(
750 &self,
751 node_names: Option<common::NodeNames>,
753 timeout: Option<String>,
756 error_trace: Option<bool>,
758 filter_path: Option<common::FilterPath>,
760 human: Option<bool>,
762 node_ids: Option<common::NodeIds>,
764 pretty: Option<bool>,
766 source: Option<String>,
768 ) -> Result<serde_json::Value, Error> {
769 let local_var_configuration = &self.configuration;
770
771 let local_var_client = &local_var_configuration.client;
772
773 let local_var_uri_str = format!(
774 "{}_cluster/voting_config_exclusions",
775 local_var_configuration.base_path
776 );
777 let mut local_var_req_builder =
778 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
779
780 if let Some(ref local_var_str) = pretty {
781 local_var_req_builder =
782 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
783 }
784 if let Some(ref local_var_str) = human {
785 local_var_req_builder =
786 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
787 }
788 if let Some(ref local_var_str) = node_ids {
789 local_var_req_builder =
790 local_var_req_builder.query(&[("node_ids", &local_var_str.to_string())]);
791 }
792 if let Some(ref local_var_str) = node_names {
793 local_var_req_builder =
794 local_var_req_builder.query(&[("node_names", &local_var_str.to_string())]);
795 }
796 if let Some(ref local_var_str) = error_trace {
797 local_var_req_builder =
798 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
799 }
800 if let Some(ref local_var_str) = timeout {
801 local_var_req_builder =
802 local_var_req_builder.query(&[("timeout", &local_var_str.to_string())]);
803 }
804 if let Some(ref local_var_str) = source {
805 local_var_req_builder =
806 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
807 }
808 if let Some(ref local_var_str) = filter_path {
809 local_var_req_builder =
810 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
811 }
812
813 let local_var_req = local_var_req_builder.build()?;
814 let local_var_resp = local_var_client.execute(local_var_req).await?;
815
816 let local_var_status = local_var_resp.status();
817 let local_var_content = local_var_resp.text().await?;
818
819 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
820 serde_json::from_str(&local_var_content).map_err(Error::from)
821 } else {
822 let local_var_error = ResponseContent {
823 status: local_var_status,
824 content: local_var_content,
825 };
826 Err(Error::ApiError(local_var_error))
827 }
828 }
829 #[builder]
833 pub async fn pending_tasks(
834 &self,
835 cluster_manager_timeout: Option<String>,
838 master_timeout: Option<String>,
841 error_trace: Option<bool>,
843 filter_path: Option<common::FilterPath>,
845 human: Option<bool>,
847 local: Option<bool>,
849 pretty: Option<bool>,
851 source: Option<String>,
853 ) -> Result<crate::cluster::PendingTasksResponse, Error> {
854 let local_var_configuration = &self.configuration;
855
856 let local_var_client = &local_var_configuration.client;
857
858 let local_var_uri_str = format!(
859 "{}_cluster/pending_tasks",
860 local_var_configuration.base_path
861 );
862 let mut local_var_req_builder =
863 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
864
865 if let Some(ref local_var_str) = source {
866 local_var_req_builder =
867 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
868 }
869 if let Some(ref local_var_str) = filter_path {
870 local_var_req_builder =
871 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
872 }
873 if let Some(ref local_var_str) = pretty {
874 local_var_req_builder =
875 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
876 }
877 if let Some(ref local_var_str) = cluster_manager_timeout {
878 local_var_req_builder = local_var_req_builder
879 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
880 }
881 if let Some(ref local_var_str) = human {
882 local_var_req_builder =
883 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
884 }
885 if let Some(ref local_var_str) = error_trace {
886 local_var_req_builder =
887 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
888 }
889 if let Some(ref local_var_str) = local {
890 local_var_req_builder =
891 local_var_req_builder.query(&[("local", &local_var_str.to_string())]);
892 }
893 if let Some(ref local_var_str) = master_timeout {
894 local_var_req_builder =
895 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
896 }
897
898 let local_var_req = local_var_req_builder.build()?;
899 let local_var_resp = local_var_client.execute(local_var_req).await?;
900
901 let local_var_status = local_var_resp.status();
902 let local_var_content = local_var_resp.text().await?;
903
904 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
905 serde_json::from_str(&local_var_content).map_err(Error::from)
906 } else {
907 let local_var_error = ResponseContent {
908 status: local_var_status,
909 content: local_var_content,
910 };
911 Err(Error::ApiError(local_var_error))
912 }
913 }
914 #[builder]
917 pub async fn reroute(
918 &self,
919 cluster_manager_timeout: Option<String>,
922 master_timeout: Option<String>,
925 timeout: Option<String>,
928 dry_run: Option<bool>,
930 error_trace: Option<bool>,
932 explain: Option<bool>,
934 filter_path: Option<common::FilterPath>,
936 human: Option<bool>,
938 metric: Option<common::Metric>,
940 pretty: Option<bool>,
942 retry_failed: Option<bool>,
944 source: Option<String>,
946 reroute: cluster::Reroute,
948 ) -> Result<String, Error> {
949 let local_var_configuration = &self.configuration;
950
951 let local_var_client = &local_var_configuration.client;
952
953 let local_var_uri_str = format!("{}_cluster/reroute", local_var_configuration.base_path);
954 let mut local_var_req_builder =
955 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
956
957 if let Some(ref local_var_str) = filter_path {
958 local_var_req_builder =
959 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
960 }
961 if let Some(ref local_var_str) = master_timeout {
962 local_var_req_builder =
963 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
964 }
965 if let Some(ref local_var_str) = metric {
966 local_var_req_builder =
967 local_var_req_builder.query(&[("metric", &local_var_str.to_string())]);
968 }
969 if let Some(ref local_var_str) = timeout {
970 local_var_req_builder =
971 local_var_req_builder.query(&[("timeout", &local_var_str.to_string())]);
972 }
973 if let Some(ref local_var_str) = pretty {
974 local_var_req_builder =
975 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
976 }
977 if let Some(ref local_var_str) = source {
978 local_var_req_builder =
979 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
980 }
981 if let Some(ref local_var_str) = human {
982 local_var_req_builder =
983 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
984 }
985 if let Some(ref local_var_str) = cluster_manager_timeout {
986 local_var_req_builder = local_var_req_builder
987 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
988 }
989 if let Some(ref local_var_str) = explain {
990 local_var_req_builder =
991 local_var_req_builder.query(&[("explain", &local_var_str.to_string())]);
992 }
993 if let Some(ref local_var_str) = error_trace {
994 local_var_req_builder =
995 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
996 }
997 if let Some(ref local_var_str) = retry_failed {
998 local_var_req_builder =
999 local_var_req_builder.query(&[("retry_failed", &local_var_str.to_string())]);
1000 }
1001 if let Some(ref local_var_str) = dry_run {
1002 local_var_req_builder =
1003 local_var_req_builder.query(&[("dry_run", &local_var_str.to_string())]);
1004 }
1005
1006 local_var_req_builder = local_var_req_builder.json(&reroute);
1007
1008 let local_var_req = local_var_req_builder.build()?;
1009 let local_var_resp = local_var_client.execute(local_var_req).await?;
1010
1011 let local_var_status = local_var_resp.status();
1012 let local_var_content = local_var_resp.text().await?;
1013
1014 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1015 serde_json::from_str(&local_var_content).map_err(Error::from)
1016 } else {
1017 let local_var_error = ResponseContent {
1018 status: local_var_status,
1019 content: local_var_content,
1020 };
1021 Err(Error::ApiError(local_var_error))
1022 }
1023 }
1024 #[builder]
1027 pub async fn allocation_explain(
1028 &self,
1029 error_trace: Option<bool>,
1031 filter_path: Option<common::FilterPath>,
1033 human: Option<bool>,
1035 include_disk_info: Option<bool>,
1037 include_yes_decisions: Option<bool>,
1039 pretty: Option<bool>,
1041 source: Option<String>,
1043 allocation_explain: cluster::AllocationExplain,
1045 ) -> Result<crate::cluster::AllocationExplainResponse, Error> {
1046 let local_var_configuration = &self.configuration;
1047
1048 let local_var_client = &local_var_configuration.client;
1049
1050 let local_var_uri_str = format!(
1051 "{}_cluster/allocation/explain",
1052 local_var_configuration.base_path
1053 );
1054 let mut local_var_req_builder =
1055 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1056
1057 if let Some(ref local_var_str) = include_disk_info {
1058 local_var_req_builder =
1059 local_var_req_builder.query(&[("include_disk_info", &local_var_str.to_string())]);
1060 }
1061 if let Some(ref local_var_str) = pretty {
1062 local_var_req_builder =
1063 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1064 }
1065 if let Some(ref local_var_str) = human {
1066 local_var_req_builder =
1067 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1068 }
1069 if let Some(ref local_var_str) = filter_path {
1070 local_var_req_builder =
1071 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1072 }
1073 if let Some(ref local_var_str) = source {
1074 local_var_req_builder =
1075 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1076 }
1077 if let Some(ref local_var_str) = error_trace {
1078 local_var_req_builder =
1079 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1080 }
1081 if let Some(ref local_var_str) = include_yes_decisions {
1082 local_var_req_builder = local_var_req_builder
1083 .query(&[("include_yes_decisions", &local_var_str.to_string())]);
1084 }
1085
1086 local_var_req_builder = local_var_req_builder.json(&allocation_explain);
1087
1088 let local_var_req = local_var_req_builder.build()?;
1089 let local_var_resp = local_var_client.execute(local_var_req).await?;
1090
1091 let local_var_status = local_var_resp.status();
1092 let local_var_content = local_var_resp.text().await?;
1093
1094 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1095 serde_json::from_str(&local_var_content).map_err(Error::from)
1096 } else {
1097 let local_var_error = ResponseContent {
1098 status: local_var_status,
1099 content: local_var_content,
1100 };
1101 Err(Error::ApiError(local_var_error))
1102 }
1103 }
1104 #[builder]
1107 pub async fn put_decommission_awareness(
1108 &self,
1109 awareness_attribute_name: String,
1111 awareness_attribute_value: String,
1113 error_trace: Option<bool>,
1115 filter_path: Option<common::FilterPath>,
1117 human: Option<bool>,
1119 pretty: Option<bool>,
1121 source: Option<String>,
1123 ) -> Result<crate::common::AcknowledgedResponseBase, Error> {
1124 let local_var_configuration = &self.configuration;
1125
1126 let local_var_client = &local_var_configuration.client;
1127
1128 let local_var_uri_str = format!("{}_cluster/decommission/awareness/{awareness_attribute_name}/{awareness_attribute_value}", local_var_configuration.base_path, awareness_attribute_name=awareness_attribute_name, awareness_attribute_value=awareness_attribute_value);
1129 let mut local_var_req_builder =
1130 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1131
1132 if let Some(ref local_var_str) = pretty {
1133 local_var_req_builder =
1134 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1135 }
1136 if let Some(ref local_var_str) = source {
1137 local_var_req_builder =
1138 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1139 }
1140 if let Some(ref local_var_str) = filter_path {
1141 local_var_req_builder =
1142 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1143 }
1144 if let Some(ref local_var_str) = human {
1145 local_var_req_builder =
1146 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1147 }
1148 if let Some(ref local_var_str) = error_trace {
1149 local_var_req_builder =
1150 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1151 }
1152
1153 let local_var_req = local_var_req_builder.build()?;
1154 let local_var_resp = local_var_client.execute(local_var_req).await?;
1155
1156 let local_var_status = local_var_resp.status();
1157 let local_var_content = local_var_resp.text().await?;
1158
1159 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1160 serde_json::from_str(&local_var_content).map_err(Error::from)
1161 } else {
1162 let local_var_error = ResponseContent {
1163 status: local_var_status,
1164 content: local_var_content,
1165 };
1166 Err(Error::ApiError(local_var_error))
1167 }
1168 }
1169 #[builder]
1172 pub async fn health(
1173 &self,
1174 cluster_manager_timeout: Option<String>,
1177 master_timeout: Option<String>,
1180 timeout: Option<String>,
1183 level: Option<String>,
1185 error_trace: Option<bool>,
1187 filter_path: Option<common::FilterPath>,
1189 human: Option<bool>,
1191 index: String,
1193 local: Option<bool>,
1195 pretty: Option<bool>,
1197 source: Option<String>,
1199 wait_for_no_initializing_shards: Option<bool>,
1201 wait_for_no_relocating_shards: Option<bool>,
1203 wait_for_nodes: Option<common::WaitForNodes>,
1205 wait_for_status: Option<common::WaitForStatus>,
1207 expand_wildcards: Option<common::ExpandWildcards>,
1209 awareness_attribute: Option<String>,
1211 wait_for_events: Option<String>,
1213 wait_for_active_shards: Option<common::wait_for_active_shards::WaitForActiveShards>,
1215 ) -> Result<crate::cluster::health::HealthResponseBody, Error> {
1216 let local_var_configuration = &self.configuration;
1217
1218 let local_var_client = &local_var_configuration.client;
1219
1220 let local_var_uri_str = format!(
1221 "{}_cluster/health/{index}",
1222 local_var_configuration.base_path,
1223 index = index
1224 );
1225 let mut local_var_req_builder =
1226 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1227
1228 if let Some(ref local_var_str) = error_trace {
1229 local_var_req_builder =
1230 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1231 }
1232 if let Some(ref local_var_str) = wait_for_no_relocating_shards {
1233 local_var_req_builder = local_var_req_builder
1234 .query(&[("wait_for_no_relocating_shards", &local_var_str.to_string())]);
1235 }
1236 if let Some(ref local_var_str) = wait_for_no_initializing_shards {
1237 local_var_req_builder = local_var_req_builder.query(&[(
1238 "wait_for_no_initializing_shards",
1239 &local_var_str.to_string(),
1240 )]);
1241 }
1242 if let Some(ref local_var_str) = master_timeout {
1243 local_var_req_builder =
1244 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
1245 }
1246 if let Some(ref local_var_str) = level {
1247 local_var_req_builder =
1248 local_var_req_builder.query(&[("level", &local_var_str.to_string())]);
1249 }
1250 if let Some(ref local_var_str) = human {
1251 local_var_req_builder =
1252 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1253 }
1254 if let Some(ref local_var_str) = expand_wildcards {
1255 local_var_req_builder =
1256 local_var_req_builder.query(&[("expand_wildcards", &local_var_str.to_string())]);
1257 }
1258 if let Some(ref local_var_str) = wait_for_nodes {
1259 local_var_req_builder =
1260 local_var_req_builder.query(&[("wait_for_nodes", &local_var_str.to_string())]);
1261 }
1262 if let Some(ref local_var_str) = filter_path {
1263 local_var_req_builder =
1264 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1265 }
1266 if let Some(ref local_var_str) = wait_for_active_shards {
1267 local_var_req_builder = local_var_req_builder
1268 .query(&[("wait_for_active_shards", &local_var_str.to_string())]);
1269 }
1270 if let Some(ref local_var_str) = source {
1271 local_var_req_builder =
1272 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1273 }
1274 if let Some(ref local_var_str) = wait_for_events {
1275 local_var_req_builder =
1276 local_var_req_builder.query(&[("wait_for_events", &local_var_str.to_string())]);
1277 }
1278 if let Some(ref local_var_str) = awareness_attribute {
1279 local_var_req_builder =
1280 local_var_req_builder.query(&[("awareness_attribute", &local_var_str.to_string())]);
1281 }
1282 if let Some(ref local_var_str) = timeout {
1283 local_var_req_builder =
1284 local_var_req_builder.query(&[("timeout", &local_var_str.to_string())]);
1285 }
1286 if let Some(ref local_var_str) = pretty {
1287 local_var_req_builder =
1288 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1289 }
1290 if let Some(ref local_var_str) = cluster_manager_timeout {
1291 local_var_req_builder = local_var_req_builder
1292 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
1293 }
1294 if let Some(ref local_var_str) = local {
1295 local_var_req_builder =
1296 local_var_req_builder.query(&[("local", &local_var_str.to_string())]);
1297 }
1298 if let Some(ref local_var_str) = wait_for_status {
1299 local_var_req_builder =
1300 local_var_req_builder.query(&[("wait_for_status", &local_var_str.to_string())]);
1301 }
1302
1303 let local_var_req = local_var_req_builder.build()?;
1304 let local_var_resp = local_var_client.execute(local_var_req).await?;
1305
1306 let local_var_status = local_var_resp.status();
1307 let local_var_content = local_var_resp.text().await?;
1308
1309 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1310 serde_json::from_str(&local_var_content).map_err(Error::from)
1311 } else {
1312 let local_var_error = ResponseContent {
1313 status: local_var_status,
1314 content: local_var_content,
1315 };
1316 Err(Error::ApiError(local_var_error))
1317 }
1318 }
1319 #[builder]
1322 pub async fn remote_info(
1323 &self,
1324 error_trace: Option<bool>,
1326 filter_path: Option<common::FilterPath>,
1328 human: Option<bool>,
1330 pretty: Option<bool>,
1332 source: Option<String>,
1334 ) -> Result<crate::cluster::RemoteInfoResponse, Error> {
1335 let local_var_configuration = &self.configuration;
1336
1337 let local_var_client = &local_var_configuration.client;
1338
1339 let local_var_uri_str = format!("{}_remote/info", local_var_configuration.base_path);
1340 let mut local_var_req_builder =
1341 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1342
1343 if let Some(ref local_var_str) = pretty {
1344 local_var_req_builder =
1345 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1346 }
1347 if let Some(ref local_var_str) = source {
1348 local_var_req_builder =
1349 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1350 }
1351 if let Some(ref local_var_str) = filter_path {
1352 local_var_req_builder =
1353 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1354 }
1355 if let Some(ref local_var_str) = human {
1356 local_var_req_builder =
1357 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1358 }
1359 if let Some(ref local_var_str) = error_trace {
1360 local_var_req_builder =
1361 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1362 }
1363
1364 let local_var_req = local_var_req_builder.build()?;
1365 let local_var_resp = local_var_client.execute(local_var_req).await?;
1366
1367 let local_var_status = local_var_resp.status();
1368 let local_var_content = local_var_resp.text().await?;
1369
1370 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1371 serde_json::from_str(&local_var_content).map_err(Error::from)
1372 } else {
1373 let local_var_error = ResponseContent {
1374 status: local_var_status,
1375 content: local_var_content,
1376 };
1377 Err(Error::ApiError(local_var_error))
1378 }
1379 }
1380 #[builder]
1383 pub async fn stats(
1384 &self,
1385 timeout: Option<String>,
1388 error_trace: Option<bool>,
1390 filter_path: Option<common::FilterPath>,
1392 flat_settings: Option<bool>,
1394 human: Option<bool>,
1396 node_id: String,
1398 pretty: Option<bool>,
1400 source: Option<String>,
1402 ) -> Result<String, Error> {
1403 let local_var_configuration = &self.configuration;
1404
1405 let local_var_client = &local_var_configuration.client;
1406
1407 let local_var_uri_str = format!(
1408 "{}_cluster/stats/nodes/{node_id}",
1409 local_var_configuration.base_path,
1410 node_id = node_id
1411 );
1412 let mut local_var_req_builder =
1413 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1414
1415 if let Some(ref local_var_str) = flat_settings {
1416 local_var_req_builder =
1417 local_var_req_builder.query(&[("flat_settings", &local_var_str.to_string())]);
1418 }
1419 if let Some(ref local_var_str) = timeout {
1420 local_var_req_builder =
1421 local_var_req_builder.query(&[("timeout", &local_var_str.to_string())]);
1422 }
1423 if let Some(ref local_var_str) = filter_path {
1424 local_var_req_builder =
1425 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1426 }
1427 if let Some(ref local_var_str) = error_trace {
1428 local_var_req_builder =
1429 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1430 }
1431 if let Some(ref local_var_str) = human {
1432 local_var_req_builder =
1433 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1434 }
1435 if let Some(ref local_var_str) = source {
1436 local_var_req_builder =
1437 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1438 }
1439 if let Some(ref local_var_str) = pretty {
1440 local_var_req_builder =
1441 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1442 }
1443
1444 let local_var_req = local_var_req_builder.build()?;
1445 let local_var_resp = local_var_client.execute(local_var_req).await?;
1446
1447 let local_var_status = local_var_resp.status();
1448 let local_var_content = local_var_resp.text().await?;
1449
1450 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1451 serde_json::from_str(&local_var_content).map_err(Error::from)
1452 } else {
1453 let local_var_error = ResponseContent {
1454 status: local_var_status,
1455 content: local_var_content,
1456 };
1457 Err(Error::ApiError(local_var_error))
1458 }
1459 }
1460 #[builder]
1463 pub async fn put_weighted_routing(
1464 &self,
1465 attribute: String,
1467 error_trace: Option<bool>,
1469 filter_path: Option<common::FilterPath>,
1471 human: Option<bool>,
1473 pretty: Option<bool>,
1475 source: Option<String>,
1477 ) -> Result<crate::cluster::PutWeightedRoutingResponse, Error> {
1478 let local_var_configuration = &self.configuration;
1479
1480 let local_var_client = &local_var_configuration.client;
1481
1482 let local_var_uri_str = format!(
1483 "{}_cluster/routing/awareness/{attribute}/weights",
1484 local_var_configuration.base_path,
1485 attribute = attribute
1486 );
1487 let mut local_var_req_builder =
1488 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1489
1490 if let Some(ref local_var_str) = filter_path {
1491 local_var_req_builder =
1492 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1493 }
1494 if let Some(ref local_var_str) = pretty {
1495 local_var_req_builder =
1496 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1497 }
1498 if let Some(ref local_var_str) = error_trace {
1499 local_var_req_builder =
1500 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1501 }
1502 if let Some(ref local_var_str) = human {
1503 local_var_req_builder =
1504 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1505 }
1506 if let Some(ref local_var_str) = source {
1507 local_var_req_builder =
1508 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1509 }
1510
1511 let local_var_req = local_var_req_builder.build()?;
1512 let local_var_resp = local_var_client.execute(local_var_req).await?;
1513
1514 let local_var_status = local_var_resp.status();
1515 let local_var_content = local_var_resp.text().await?;
1516
1517 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1518 serde_json::from_str(&local_var_content).map_err(Error::from)
1519 } else {
1520 let local_var_error = ResponseContent {
1521 status: local_var_status,
1522 content: local_var_content,
1523 };
1524 Err(Error::ApiError(local_var_error))
1525 }
1526 }
1527 #[builder]
1530 pub async fn put_component_template(
1531 &self,
1532 cluster_manager_timeout: Option<String>,
1535 master_timeout: Option<String>,
1538 timeout: Option<String>,
1541 create: Option<bool>,
1543 error_trace: Option<bool>,
1545 filter_path: Option<common::FilterPath>,
1547 human: Option<bool>,
1549 name: String,
1551 pretty: Option<bool>,
1553 source: Option<String>,
1555 put_component_template: cluster::PutComponentTemplate,
1557 ) -> Result<crate::common::AcknowledgedResponseBase, Error> {
1558 let local_var_configuration = &self.configuration;
1559
1560 let local_var_client = &local_var_configuration.client;
1561
1562 let local_var_uri_str = format!(
1563 "{}_component_template/{name}",
1564 local_var_configuration.base_path,
1565 name = name
1566 );
1567 let mut local_var_req_builder =
1568 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1569
1570 if let Some(ref local_var_str) = create {
1571 local_var_req_builder =
1572 local_var_req_builder.query(&[("create", &local_var_str.to_string())]);
1573 }
1574 if let Some(ref local_var_str) = cluster_manager_timeout {
1575 local_var_req_builder = local_var_req_builder
1576 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
1577 }
1578 if let Some(ref local_var_str) = human {
1579 local_var_req_builder =
1580 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1581 }
1582 if let Some(ref local_var_str) = error_trace {
1583 local_var_req_builder =
1584 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1585 }
1586 if let Some(ref local_var_str) = timeout {
1587 local_var_req_builder =
1588 local_var_req_builder.query(&[("timeout", &local_var_str.to_string())]);
1589 }
1590 if let Some(ref local_var_str) = pretty {
1591 local_var_req_builder =
1592 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1593 }
1594 if let Some(ref local_var_str) = master_timeout {
1595 local_var_req_builder =
1596 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
1597 }
1598 if let Some(ref local_var_str) = filter_path {
1599 local_var_req_builder =
1600 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1601 }
1602 if let Some(ref local_var_str) = source {
1603 local_var_req_builder =
1604 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1605 }
1606
1607 local_var_req_builder = local_var_req_builder.json(&put_component_template);
1608
1609 let local_var_req = local_var_req_builder.build()?;
1610 let local_var_resp = local_var_client.execute(local_var_req).await?;
1611
1612 let local_var_status = local_var_resp.status();
1613 let local_var_content = local_var_resp.text().await?;
1614
1615 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1616 serde_json::from_str(&local_var_content).map_err(Error::from)
1617 } else {
1618 let local_var_error = ResponseContent {
1619 status: local_var_status,
1620 content: local_var_content,
1621 };
1622 Err(Error::ApiError(local_var_error))
1623 }
1624 }
1625 #[builder]
1628 pub async fn delete_voting_config_exclusions(
1629 &self,
1630 error_trace: Option<bool>,
1632 filter_path: Option<common::FilterPath>,
1634 human: Option<bool>,
1636 pretty: Option<bool>,
1638 source: Option<String>,
1640 wait_for_removal: Option<bool>,
1642 ) -> Result<serde_json::Value, Error> {
1643 let local_var_configuration = &self.configuration;
1644
1645 let local_var_client = &local_var_configuration.client;
1646
1647 let local_var_uri_str = format!(
1648 "{}_cluster/voting_config_exclusions",
1649 local_var_configuration.base_path
1650 );
1651 let mut local_var_req_builder =
1652 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1653
1654 if let Some(ref local_var_str) = pretty {
1655 local_var_req_builder =
1656 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1657 }
1658 if let Some(ref local_var_str) = error_trace {
1659 local_var_req_builder =
1660 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1661 }
1662 if let Some(ref local_var_str) = source {
1663 local_var_req_builder =
1664 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1665 }
1666 if let Some(ref local_var_str) = filter_path {
1667 local_var_req_builder =
1668 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1669 }
1670 if let Some(ref local_var_str) = wait_for_removal {
1671 local_var_req_builder =
1672 local_var_req_builder.query(&[("wait_for_removal", &local_var_str.to_string())]);
1673 }
1674 if let Some(ref local_var_str) = human {
1675 local_var_req_builder =
1676 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1677 }
1678
1679 let local_var_req = local_var_req_builder.build()?;
1680 let local_var_resp = local_var_client.execute(local_var_req).await?;
1681
1682 let local_var_status = local_var_resp.status();
1683 let local_var_content = local_var_resp.text().await?;
1684
1685 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1686 serde_json::from_str(&local_var_content).map_err(Error::from)
1687 } else {
1688 let local_var_error = ResponseContent {
1689 status: local_var_status,
1690 content: local_var_content,
1691 };
1692 Err(Error::ApiError(local_var_error))
1693 }
1694 }
1695 #[builder]
1698 pub async fn state(
1699 &self,
1700 cluster_manager_timeout: Option<String>,
1703 master_timeout: Option<String>,
1706 wait_for_timeout: Option<String>,
1709 allow_no_indices: Option<bool>,
1711 error_trace: Option<bool>,
1713 filter_path: Option<common::FilterPath>,
1715 flat_settings: Option<bool>,
1717 human: Option<bool>,
1719 ignore_unavailable: Option<bool>,
1721 index: String,
1723 local: Option<bool>,
1725 metric: String,
1727 pretty: Option<bool>,
1729 source: Option<String>,
1731 wait_for_metadata_version: Option<i32>,
1733 expand_wildcards: Option<common::ExpandWildcards>,
1735 ) -> Result<serde_json::Value, Error> {
1736 let local_var_configuration = &self.configuration;
1737
1738 let local_var_client = &local_var_configuration.client;
1739
1740 let local_var_uri_str = format!(
1741 "{}_cluster/state/{metric}/{index}",
1742 local_var_configuration.base_path,
1743 index = index,
1744 metric = metric
1745 );
1746 let mut local_var_req_builder =
1747 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1748
1749 if let Some(ref local_var_str) = pretty {
1750 local_var_req_builder =
1751 local_var_req_builder.query(&[("pretty", &local_var_str.to_string())]);
1752 }
1753 if let Some(ref local_var_str) = allow_no_indices {
1754 local_var_req_builder =
1755 local_var_req_builder.query(&[("allow_no_indices", &local_var_str.to_string())]);
1756 }
1757 if let Some(ref local_var_str) = local {
1758 local_var_req_builder =
1759 local_var_req_builder.query(&[("local", &local_var_str.to_string())]);
1760 }
1761 if let Some(ref local_var_str) = human {
1762 local_var_req_builder =
1763 local_var_req_builder.query(&[("human", &local_var_str.to_string())]);
1764 }
1765 if let Some(ref local_var_str) = error_trace {
1766 local_var_req_builder =
1767 local_var_req_builder.query(&[("error_trace", &local_var_str.to_string())]);
1768 }
1769 if let Some(ref local_var_str) = source {
1770 local_var_req_builder =
1771 local_var_req_builder.query(&[("source", &local_var_str.to_string())]);
1772 }
1773 if let Some(ref local_var_str) = filter_path {
1774 local_var_req_builder =
1775 local_var_req_builder.query(&[("filter_path", &local_var_str.to_string())]);
1776 }
1777 if let Some(ref local_var_str) = cluster_manager_timeout {
1778 local_var_req_builder = local_var_req_builder
1779 .query(&[("cluster_manager_timeout", &local_var_str.to_string())]);
1780 }
1781 if let Some(ref local_var_str) = flat_settings {
1782 local_var_req_builder =
1783 local_var_req_builder.query(&[("flat_settings", &local_var_str.to_string())]);
1784 }
1785 if let Some(ref local_var_str) = expand_wildcards {
1786 local_var_req_builder =
1787 local_var_req_builder.query(&[("expand_wildcards", &local_var_str.to_string())]);
1788 }
1789 if let Some(ref local_var_str) = wait_for_metadata_version {
1790 local_var_req_builder = local_var_req_builder
1791 .query(&[("wait_for_metadata_version", &local_var_str.to_string())]);
1792 }
1793 if let Some(ref local_var_str) = ignore_unavailable {
1794 local_var_req_builder =
1795 local_var_req_builder.query(&[("ignore_unavailable", &local_var_str.to_string())]);
1796 }
1797 if let Some(ref local_var_str) = master_timeout {
1798 local_var_req_builder =
1799 local_var_req_builder.query(&[("master_timeout", &local_var_str.to_string())]);
1800 }
1801 if let Some(ref local_var_str) = wait_for_timeout {
1802 local_var_req_builder =
1803 local_var_req_builder.query(&[("wait_for_timeout", &local_var_str.to_string())]);
1804 }
1805
1806 let local_var_req = local_var_req_builder.build()?;
1807 let local_var_resp = local_var_client.execute(local_var_req).await?;
1808
1809 let local_var_status = local_var_resp.status();
1810 let local_var_content = local_var_resp.text().await?;
1811
1812 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1813 serde_json::from_str(&local_var_content).map_err(Error::from)
1814 } else {
1815 let local_var_error = ResponseContent {
1816 status: local_var_status,
1817 content: local_var_content,
1818 };
1819 Err(Error::ApiError(local_var_error))
1820 }
1821 }
1822}