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 ClustersBaseCreateClusterError {
22 Status400(),
23 Status403(),
24 Status409(),
25 Status412(),
26 Status500(),
27 UnknownValue(serde_json::Value),
28}
29
30#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum ClustersBaseDeleteClusterError {
34 Status403(),
35 Status404(),
36 Status412(),
37 Status500(),
38 UnknownValue(serde_json::Value),
39}
40
41#[derive(Debug, Clone, Serialize, Deserialize)]
43#[serde(untagged)]
44pub enum ClustersBaseDeleteFailureDomainError {
45 Status403(),
46 Status404(),
47 Status412(),
48 Status500(),
49 UnknownValue(serde_json::Value),
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum ClustersBaseDeleteNamespaceIsolationPolicyError {
56 Status403(),
57 Status404(),
58 Status412(),
59 Status500(),
60 UnknownValue(serde_json::Value),
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(untagged)]
66pub enum ClustersBaseGetBrokerWithNamespaceIsolationPolicyError {
67 Status403(),
68 Status404(),
69 Status412(),
70 Status500(),
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum ClustersBaseGetBrokersWithNamespaceIsolationPolicyError {
78 Status403(),
79 Status404(),
80 Status412(),
81 Status500(),
82 UnknownValue(serde_json::Value),
83}
84
85#[derive(Debug, Clone, Serialize, Deserialize)]
87#[serde(untagged)]
88pub enum ClustersBaseGetClusterError {
89 Status403(),
90 Status404(),
91 Status500(),
92 UnknownValue(serde_json::Value),
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum ClustersBaseGetClusterMigrationError {
99 Status403(),
100 Status404(),
101 Status500(),
102 UnknownValue(serde_json::Value),
103}
104
105#[derive(Debug, Clone, Serialize, Deserialize)]
107#[serde(untagged)]
108pub enum ClustersBaseGetClustersError {
109 Status500(),
110 UnknownValue(serde_json::Value),
111}
112
113#[derive(Debug, Clone, Serialize, Deserialize)]
115#[serde(untagged)]
116pub enum ClustersBaseGetDomainError {
117 Status403(),
118 Status404(),
119 Status412(),
120 Status500(),
121 UnknownValue(serde_json::Value),
122}
123
124#[derive(Debug, Clone, Serialize, Deserialize)]
126#[serde(untagged)]
127pub enum ClustersBaseGetFailureDomainsError {
128 Status403(),
129 Status500(),
130 UnknownValue(serde_json::Value),
131}
132
133#[derive(Debug, Clone, Serialize, Deserialize)]
135#[serde(untagged)]
136pub enum ClustersBaseGetNamespaceIsolationPoliciesError {
137 Status403(),
138 Status404(),
139 Status500(),
140 UnknownValue(serde_json::Value),
141}
142
143#[derive(Debug, Clone, Serialize, Deserialize)]
145#[serde(untagged)]
146pub enum ClustersBaseGetNamespaceIsolationPolicyError {
147 Status403(),
148 Status404(),
149 Status412(),
150 Status500(),
151 UnknownValue(serde_json::Value),
152}
153
154#[derive(Debug, Clone, Serialize, Deserialize)]
156#[serde(untagged)]
157pub enum ClustersBaseGetPeerClusterError {
158 Status403(),
159 Status404(),
160 Status500(),
161 UnknownValue(serde_json::Value),
162}
163
164#[derive(Debug, Clone, Serialize, Deserialize)]
166#[serde(untagged)]
167pub enum ClustersBaseSetFailureDomainError {
168 Status403(),
169 Status404(),
170 Status409(),
171 Status412(),
172 Status500(),
173 UnknownValue(serde_json::Value),
174}
175
176#[derive(Debug, Clone, Serialize, Deserialize)]
178#[serde(untagged)]
179pub enum ClustersBaseSetNamespaceIsolationPolicyError {
180 Status400(),
181 Status403(),
182 Status404(),
183 Status412(),
184 Status500(),
185 UnknownValue(serde_json::Value),
186}
187
188#[derive(Debug, Clone, Serialize, Deserialize)]
190#[serde(untagged)]
191pub enum ClustersBaseSetPeerClusterNamesError {
192 Status403(),
193 Status404(),
194 Status412(),
195 Status500(),
196 UnknownValue(serde_json::Value),
197}
198
199#[derive(Debug, Clone, Serialize, Deserialize)]
201#[serde(untagged)]
202pub enum ClustersBaseUpdateClusterError {
203 Status400(),
204 Status403(),
205 Status404(),
206 Status500(),
207 UnknownValue(serde_json::Value),
208}
209
210#[derive(Debug, Clone, Serialize, Deserialize)]
212#[serde(untagged)]
213pub enum ClustersBaseUpdateClusterMigrationError {
214 Status400(),
215 Status403(),
216 Status404(),
217 Status500(),
218 UnknownValue(serde_json::Value),
219}
220
221
222pub async fn clusters_base_create_cluster(configuration: &configuration::Configuration, cluster: &str, body: models::ClusterData) -> Result<(), Error<ClustersBaseCreateClusterError>> {
224 let local_var_configuration = configuration;
225
226 let local_var_client = &local_var_configuration.client;
227
228 let local_var_uri_str = format!("{}/clusters/{cluster}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
229 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
230
231 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
232 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
233 }
234 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
235 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
236 };
237 local_var_req_builder = local_var_req_builder.json(&body);
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 Ok(())
247 } else {
248 let local_var_entity: Option<ClustersBaseCreateClusterError> = 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 clusters_base_delete_cluster(configuration: &configuration::Configuration, cluster: &str) -> Result<(), Error<ClustersBaseDeleteClusterError>> {
256 let local_var_configuration = configuration;
257
258 let local_var_client = &local_var_configuration.client;
259
260 let local_var_uri_str = format!("{}/clusters/{cluster}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
261 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
262
263 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
264 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
265 }
266 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
267 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
268 };
269
270 let local_var_req = local_var_req_builder.build()?;
271 let local_var_resp = local_var_client.execute(local_var_req).await?;
272
273 let local_var_status = local_var_resp.status();
274 let local_var_content = local_var_resp.text().await?;
275
276 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
277 Ok(())
278 } else {
279 let local_var_entity: Option<ClustersBaseDeleteClusterError> = serde_json::from_str(&local_var_content).ok();
280 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
281 Err(Error::ResponseError(local_var_error))
282 }
283}
284
285pub async fn clusters_base_delete_failure_domain(configuration: &configuration::Configuration, cluster: &str, domain_name: &str) -> Result<(), Error<ClustersBaseDeleteFailureDomainError>> {
287 let local_var_configuration = configuration;
288
289 let local_var_client = &local_var_configuration.client;
290
291 let local_var_uri_str = format!("{}/clusters/{cluster}/failureDomains/{domainName}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster), domainName=crate::apis::urlencode(domain_name));
292 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
293
294 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
295 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
296 }
297 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
298 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
299 };
300
301 let local_var_req = local_var_req_builder.build()?;
302 let local_var_resp = local_var_client.execute(local_var_req).await?;
303
304 let local_var_status = local_var_resp.status();
305 let local_var_content = local_var_resp.text().await?;
306
307 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
308 Ok(())
309 } else {
310 let local_var_entity: Option<ClustersBaseDeleteFailureDomainError> = serde_json::from_str(&local_var_content).ok();
311 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
312 Err(Error::ResponseError(local_var_error))
313 }
314}
315
316pub async fn clusters_base_delete_namespace_isolation_policy(configuration: &configuration::Configuration, cluster: &str, policy_name: &str) -> Result<(), Error<ClustersBaseDeleteNamespaceIsolationPolicyError>> {
318 let local_var_configuration = configuration;
319
320 let local_var_client = &local_var_configuration.client;
321
322 let local_var_uri_str = format!("{}/clusters/{cluster}/namespaceIsolationPolicies/{policyName}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster), policyName=crate::apis::urlencode(policy_name));
323 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
324
325 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
326 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
327 }
328 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
329 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
330 };
331
332 let local_var_req = local_var_req_builder.build()?;
333 let local_var_resp = local_var_client.execute(local_var_req).await?;
334
335 let local_var_status = local_var_resp.status();
336 let local_var_content = local_var_resp.text().await?;
337
338 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
339 Ok(())
340 } else {
341 let local_var_entity: Option<ClustersBaseDeleteNamespaceIsolationPolicyError> = serde_json::from_str(&local_var_content).ok();
342 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
343 Err(Error::ResponseError(local_var_error))
344 }
345}
346
347pub async fn clusters_base_get_broker_with_namespace_isolation_policy(configuration: &configuration::Configuration, cluster: &str, broker: &str) -> Result<models::BrokerNamespaceIsolationData, Error<ClustersBaseGetBrokerWithNamespaceIsolationPolicyError>> {
349 let local_var_configuration = configuration;
350
351 let local_var_client = &local_var_configuration.client;
352
353 let local_var_uri_str = format!("{}/clusters/{cluster}/namespaceIsolationPolicies/brokers/{broker}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster), broker=crate::apis::urlencode(broker));
354 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
355
356 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
357 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
358 }
359 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
360 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
361 };
362
363 let local_var_req = local_var_req_builder.build()?;
364 let local_var_resp = local_var_client.execute(local_var_req).await?;
365
366 let local_var_status = local_var_resp.status();
367 let local_var_content = local_var_resp.text().await?;
368
369 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
370 serde_json::from_str(&local_var_content).map_err(Error::from)
371 } else {
372 let local_var_entity: Option<ClustersBaseGetBrokerWithNamespaceIsolationPolicyError> = serde_json::from_str(&local_var_content).ok();
373 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
374 Err(Error::ResponseError(local_var_error))
375 }
376}
377
378pub async fn clusters_base_get_brokers_with_namespace_isolation_policy(configuration: &configuration::Configuration, cluster: &str) -> Result<Vec<models::BrokerNamespaceIsolationData>, Error<ClustersBaseGetBrokersWithNamespaceIsolationPolicyError>> {
380 let local_var_configuration = configuration;
381
382 let local_var_client = &local_var_configuration.client;
383
384 let local_var_uri_str = format!("{}/clusters/{cluster}/namespaceIsolationPolicies/brokers", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
385 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
386
387 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
388 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
389 }
390 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
391 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
392 };
393
394 let local_var_req = local_var_req_builder.build()?;
395 let local_var_resp = local_var_client.execute(local_var_req).await?;
396
397 let local_var_status = local_var_resp.status();
398 let local_var_content = local_var_resp.text().await?;
399
400 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
401 serde_json::from_str(&local_var_content).map_err(Error::from)
402 } else {
403 let local_var_entity: Option<ClustersBaseGetBrokersWithNamespaceIsolationPolicyError> = serde_json::from_str(&local_var_content).ok();
404 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
405 Err(Error::ResponseError(local_var_error))
406 }
407}
408
409pub async fn clusters_base_get_cluster(configuration: &configuration::Configuration, cluster: &str) -> Result<models::ClusterData, Error<ClustersBaseGetClusterError>> {
411 let local_var_configuration = configuration;
412
413 let local_var_client = &local_var_configuration.client;
414
415 let local_var_uri_str = format!("{}/clusters/{cluster}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
416 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
417
418 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
419 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
420 }
421 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
422 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
423 };
424
425 let local_var_req = local_var_req_builder.build()?;
426 let local_var_resp = local_var_client.execute(local_var_req).await?;
427
428 let local_var_status = local_var_resp.status();
429 let local_var_content = local_var_resp.text().await?;
430
431 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
432 serde_json::from_str(&local_var_content).map_err(Error::from)
433 } else {
434 let local_var_entity: Option<ClustersBaseGetClusterError> = serde_json::from_str(&local_var_content).ok();
435 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
436 Err(Error::ResponseError(local_var_error))
437 }
438}
439
440pub async fn clusters_base_get_cluster_migration(configuration: &configuration::Configuration, cluster: &str) -> Result<models::ClusterData, Error<ClustersBaseGetClusterMigrationError>> {
442 let local_var_configuration = configuration;
443
444 let local_var_client = &local_var_configuration.client;
445
446 let local_var_uri_str = format!("{}/clusters/{cluster}/migrate", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
447 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
448
449 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
450 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
451 }
452 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
453 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
454 };
455
456 let local_var_req = local_var_req_builder.build()?;
457 let local_var_resp = local_var_client.execute(local_var_req).await?;
458
459 let local_var_status = local_var_resp.status();
460 let local_var_content = local_var_resp.text().await?;
461
462 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
463 serde_json::from_str(&local_var_content).map_err(Error::from)
464 } else {
465 let local_var_entity: Option<ClustersBaseGetClusterMigrationError> = serde_json::from_str(&local_var_content).ok();
466 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
467 Err(Error::ResponseError(local_var_error))
468 }
469}
470
471pub async fn clusters_base_get_clusters(configuration: &configuration::Configuration, ) -> Result<Vec<String>, Error<ClustersBaseGetClustersError>> {
472 let local_var_configuration = configuration;
473
474 let local_var_client = &local_var_configuration.client;
475
476 let local_var_uri_str = format!("{}/clusters", local_var_configuration.base_path);
477 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
478
479 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
480 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
481 }
482 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
483 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
484 };
485
486 let local_var_req = local_var_req_builder.build()?;
487 let local_var_resp = local_var_client.execute(local_var_req).await?;
488
489 let local_var_status = local_var_resp.status();
490 let local_var_content = local_var_resp.text().await?;
491
492 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
493 serde_json::from_str(&local_var_content).map_err(Error::from)
494 } else {
495 let local_var_entity: Option<ClustersBaseGetClustersError> = serde_json::from_str(&local_var_content).ok();
496 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
497 Err(Error::ResponseError(local_var_error))
498 }
499}
500
501pub async fn clusters_base_get_domain(configuration: &configuration::Configuration, cluster: &str, domain_name: &str) -> Result<models::FailureDomain, Error<ClustersBaseGetDomainError>> {
503 let local_var_configuration = configuration;
504
505 let local_var_client = &local_var_configuration.client;
506
507 let local_var_uri_str = format!("{}/clusters/{cluster}/failureDomains/{domainName}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster), domainName=crate::apis::urlencode(domain_name));
508 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
509
510 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
511 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
512 }
513 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
514 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
515 };
516
517 let local_var_req = local_var_req_builder.build()?;
518 let local_var_resp = local_var_client.execute(local_var_req).await?;
519
520 let local_var_status = local_var_resp.status();
521 let local_var_content = local_var_resp.text().await?;
522
523 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
524 serde_json::from_str(&local_var_content).map_err(Error::from)
525 } else {
526 let local_var_entity: Option<ClustersBaseGetDomainError> = serde_json::from_str(&local_var_content).ok();
527 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
528 Err(Error::ResponseError(local_var_error))
529 }
530}
531
532pub async fn clusters_base_get_failure_domains(configuration: &configuration::Configuration, cluster: &str) -> Result<std::collections::HashMap<String, models::FailureDomain>, Error<ClustersBaseGetFailureDomainsError>> {
534 let local_var_configuration = configuration;
535
536 let local_var_client = &local_var_configuration.client;
537
538 let local_var_uri_str = format!("{}/clusters/{cluster}/failureDomains", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
539 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
540
541 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
542 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
543 }
544 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
545 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
546 };
547
548 let local_var_req = local_var_req_builder.build()?;
549 let local_var_resp = local_var_client.execute(local_var_req).await?;
550
551 let local_var_status = local_var_resp.status();
552 let local_var_content = local_var_resp.text().await?;
553
554 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
555 serde_json::from_str(&local_var_content).map_err(Error::from)
556 } else {
557 let local_var_entity: Option<ClustersBaseGetFailureDomainsError> = serde_json::from_str(&local_var_content).ok();
558 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
559 Err(Error::ResponseError(local_var_error))
560 }
561}
562
563pub async fn clusters_base_get_namespace_isolation_policies(configuration: &configuration::Configuration, cluster: &str) -> Result<std::collections::HashMap<String, models::NamespaceIsolationData>, Error<ClustersBaseGetNamespaceIsolationPoliciesError>> {
565 let local_var_configuration = configuration;
566
567 let local_var_client = &local_var_configuration.client;
568
569 let local_var_uri_str = format!("{}/clusters/{cluster}/namespaceIsolationPolicies", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
570 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
571
572 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
573 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
574 }
575 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
576 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
577 };
578
579 let local_var_req = local_var_req_builder.build()?;
580 let local_var_resp = local_var_client.execute(local_var_req).await?;
581
582 let local_var_status = local_var_resp.status();
583 let local_var_content = local_var_resp.text().await?;
584
585 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
586 serde_json::from_str(&local_var_content).map_err(Error::from)
587 } else {
588 let local_var_entity: Option<ClustersBaseGetNamespaceIsolationPoliciesError> = serde_json::from_str(&local_var_content).ok();
589 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
590 Err(Error::ResponseError(local_var_error))
591 }
592}
593
594pub async fn clusters_base_get_namespace_isolation_policy(configuration: &configuration::Configuration, cluster: &str, policy_name: &str) -> Result<models::NamespaceIsolationData, Error<ClustersBaseGetNamespaceIsolationPolicyError>> {
596 let local_var_configuration = configuration;
597
598 let local_var_client = &local_var_configuration.client;
599
600 let local_var_uri_str = format!("{}/clusters/{cluster}/namespaceIsolationPolicies/{policyName}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster), policyName=crate::apis::urlencode(policy_name));
601 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
602
603 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
604 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
605 }
606 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
607 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
608 };
609
610 let local_var_req = local_var_req_builder.build()?;
611 let local_var_resp = local_var_client.execute(local_var_req).await?;
612
613 let local_var_status = local_var_resp.status();
614 let local_var_content = local_var_resp.text().await?;
615
616 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
617 serde_json::from_str(&local_var_content).map_err(Error::from)
618 } else {
619 let local_var_entity: Option<ClustersBaseGetNamespaceIsolationPolicyError> = serde_json::from_str(&local_var_content).ok();
620 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
621 Err(Error::ResponseError(local_var_error))
622 }
623}
624
625pub async fn clusters_base_get_peer_cluster(configuration: &configuration::Configuration, cluster: &str) -> Result<Vec<String>, Error<ClustersBaseGetPeerClusterError>> {
627 let local_var_configuration = configuration;
628
629 let local_var_client = &local_var_configuration.client;
630
631 let local_var_uri_str = format!("{}/clusters/{cluster}/peers", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
632 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
633
634 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
635 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
636 }
637 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
638 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
639 };
640
641 let local_var_req = local_var_req_builder.build()?;
642 let local_var_resp = local_var_client.execute(local_var_req).await?;
643
644 let local_var_status = local_var_resp.status();
645 let local_var_content = local_var_resp.text().await?;
646
647 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
648 serde_json::from_str(&local_var_content).map_err(Error::from)
649 } else {
650 let local_var_entity: Option<ClustersBaseGetPeerClusterError> = serde_json::from_str(&local_var_content).ok();
651 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
652 Err(Error::ResponseError(local_var_error))
653 }
654}
655
656pub async fn clusters_base_set_failure_domain(configuration: &configuration::Configuration, cluster: &str, domain_name: &str, body: models::FailureDomain) -> Result<(), Error<ClustersBaseSetFailureDomainError>> {
658 let local_var_configuration = configuration;
659
660 let local_var_client = &local_var_configuration.client;
661
662 let local_var_uri_str = format!("{}/clusters/{cluster}/failureDomains/{domainName}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster), domainName=crate::apis::urlencode(domain_name));
663 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
664
665 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
666 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
667 }
668 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
669 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
670 };
671 local_var_req_builder = local_var_req_builder.json(&body);
672
673 let local_var_req = local_var_req_builder.build()?;
674 let local_var_resp = local_var_client.execute(local_var_req).await?;
675
676 let local_var_status = local_var_resp.status();
677 let local_var_content = local_var_resp.text().await?;
678
679 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
680 Ok(())
681 } else {
682 let local_var_entity: Option<ClustersBaseSetFailureDomainError> = serde_json::from_str(&local_var_content).ok();
683 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
684 Err(Error::ResponseError(local_var_error))
685 }
686}
687
688pub async fn clusters_base_set_namespace_isolation_policy(configuration: &configuration::Configuration, cluster: &str, policy_name: &str, body: models::NamespaceIsolationData) -> Result<(), Error<ClustersBaseSetNamespaceIsolationPolicyError>> {
690 let local_var_configuration = configuration;
691
692 let local_var_client = &local_var_configuration.client;
693
694 let local_var_uri_str = format!("{}/clusters/{cluster}/namespaceIsolationPolicies/{policyName}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster), policyName=crate::apis::urlencode(policy_name));
695 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
696
697 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
698 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
699 }
700 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
701 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
702 };
703 local_var_req_builder = local_var_req_builder.json(&body);
704
705 let local_var_req = local_var_req_builder.build()?;
706 let local_var_resp = local_var_client.execute(local_var_req).await?;
707
708 let local_var_status = local_var_resp.status();
709 let local_var_content = local_var_resp.text().await?;
710
711 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
712 Ok(())
713 } else {
714 let local_var_entity: Option<ClustersBaseSetNamespaceIsolationPolicyError> = serde_json::from_str(&local_var_content).ok();
715 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
716 Err(Error::ResponseError(local_var_error))
717 }
718}
719
720pub async fn clusters_base_set_peer_cluster_names(configuration: &configuration::Configuration, cluster: &str, body: Vec<String>) -> Result<(), Error<ClustersBaseSetPeerClusterNamesError>> {
722 let local_var_configuration = configuration;
723
724 let local_var_client = &local_var_configuration.client;
725
726 let local_var_uri_str = format!("{}/clusters/{cluster}/peers", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
727 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
728
729 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
730 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
731 }
732 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
733 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
734 };
735 local_var_req_builder = local_var_req_builder.json(&body);
736
737 let local_var_req = local_var_req_builder.build()?;
738 let local_var_resp = local_var_client.execute(local_var_req).await?;
739
740 let local_var_status = local_var_resp.status();
741 let local_var_content = local_var_resp.text().await?;
742
743 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
744 Ok(())
745 } else {
746 let local_var_entity: Option<ClustersBaseSetPeerClusterNamesError> = serde_json::from_str(&local_var_content).ok();
747 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
748 Err(Error::ResponseError(local_var_error))
749 }
750}
751
752pub async fn clusters_base_update_cluster(configuration: &configuration::Configuration, cluster: &str, body: models::ClusterData) -> Result<(), Error<ClustersBaseUpdateClusterError>> {
754 let local_var_configuration = configuration;
755
756 let local_var_client = &local_var_configuration.client;
757
758 let local_var_uri_str = format!("{}/clusters/{cluster}", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
759 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
760
761 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
762 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
763 }
764 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
765 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
766 };
767 local_var_req_builder = local_var_req_builder.json(&body);
768
769 let local_var_req = local_var_req_builder.build()?;
770 let local_var_resp = local_var_client.execute(local_var_req).await?;
771
772 let local_var_status = local_var_resp.status();
773 let local_var_content = local_var_resp.text().await?;
774
775 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
776 Ok(())
777 } else {
778 let local_var_entity: Option<ClustersBaseUpdateClusterError> = serde_json::from_str(&local_var_content).ok();
779 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
780 Err(Error::ResponseError(local_var_error))
781 }
782}
783
784pub async fn clusters_base_update_cluster_migration(configuration: &configuration::Configuration, cluster: &str, migrated: bool, body: models::ClusterUrl) -> Result<(), Error<ClustersBaseUpdateClusterMigrationError>> {
786 let local_var_configuration = configuration;
787
788 let local_var_client = &local_var_configuration.client;
789
790 let local_var_uri_str = format!("{}/clusters/{cluster}/migrate", local_var_configuration.base_path, cluster=crate::apis::urlencode(cluster));
791 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
792
793 local_var_req_builder = local_var_req_builder.query(&[("migrated", &migrated.to_string())]);
794 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
795 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
796 }
797 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
798 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
799 };
800 local_var_req_builder = local_var_req_builder.json(&body);
801
802 let local_var_req = local_var_req_builder.build()?;
803 let local_var_resp = local_var_client.execute(local_var_req).await?;
804
805 let local_var_status = local_var_resp.status();
806 let local_var_content = local_var_resp.text().await?;
807
808 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
809 Ok(())
810 } else {
811 let local_var_entity: Option<ClustersBaseUpdateClusterMigrationError> = serde_json::from_str(&local_var_content).ok();
812 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
813 Err(Error::ResponseError(local_var_error))
814 }
815}
816