openapi_service_fabric/apis/
repair_management_api.rs

1/*
2 * Service Fabric Client APIs
3 *
4 * Service Fabric REST Client APIs allows management of Service Fabric clusters, applications and services.
5 *
6 * The version of the OpenAPI document: 8.2
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use super::{configuration, ContentType, Error};
12use crate::{apis::ResponseContent, models};
13use reqwest;
14use serde::{de::Error as _, Deserialize, Serialize};
15
16/// struct for typed errors of method [`cancel_repair_task`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum CancelRepairTaskError {
20    DefaultResponse(models::FabricError),
21    UnknownValue(serde_json::Value),
22}
23
24/// struct for typed errors of method [`create_repair_task`]
25#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum CreateRepairTaskError {
28    DefaultResponse(models::FabricError),
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`delete_repair_task`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum DeleteRepairTaskError {
36    DefaultResponse(models::FabricError),
37    UnknownValue(serde_json::Value),
38}
39
40/// struct for typed errors of method [`force_approve_repair_task`]
41#[derive(Debug, Clone, Serialize, Deserialize)]
42#[serde(untagged)]
43pub enum ForceApproveRepairTaskError {
44    DefaultResponse(models::FabricError),
45    UnknownValue(serde_json::Value),
46}
47
48/// struct for typed errors of method [`get_repair_task_list`]
49#[derive(Debug, Clone, Serialize, Deserialize)]
50#[serde(untagged)]
51pub enum GetRepairTaskListError {
52    DefaultResponse(models::FabricError),
53    UnknownValue(serde_json::Value),
54}
55
56/// struct for typed errors of method [`update_repair_execution_state`]
57#[derive(Debug, Clone, Serialize, Deserialize)]
58#[serde(untagged)]
59pub enum UpdateRepairExecutionStateError {
60    DefaultResponse(models::FabricError),
61    UnknownValue(serde_json::Value),
62}
63
64/// struct for typed errors of method [`update_repair_task_health_policy`]
65#[derive(Debug, Clone, Serialize, Deserialize)]
66#[serde(untagged)]
67pub enum UpdateRepairTaskHealthPolicyError {
68    DefaultResponse(models::FabricError),
69    UnknownValue(serde_json::Value),
70}
71
72/// This API supports the Service Fabric platform; it is not meant to be used directly from your code.
73pub async fn cancel_repair_task(
74    configuration: &configuration::Configuration,
75    api_version: &str,
76    repair_task_cancel_description: models::RepairTaskCancelDescription,
77) -> Result<models::RepairTaskUpdateInfo, Error<CancelRepairTaskError>> {
78    // add a prefix to parameters to efficiently prevent name collisions
79    let p_query_api_version = api_version;
80    let p_body_repair_task_cancel_description = repair_task_cancel_description;
81
82    let uri_str = format!("{}/$/CancelRepairTask", configuration.base_path);
83    let mut req_builder = configuration
84        .client
85        .request(reqwest::Method::POST, &uri_str);
86
87    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
88    if let Some(ref user_agent) = configuration.user_agent {
89        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
90    }
91    req_builder = req_builder.json(&p_body_repair_task_cancel_description);
92
93    let req = req_builder.build()?;
94    let resp = configuration.client.execute(req).await?;
95
96    let status = resp.status();
97    let content_type = resp
98        .headers()
99        .get("content-type")
100        .and_then(|v| v.to_str().ok())
101        .unwrap_or("application/octet-stream");
102    let content_type = super::ContentType::from(content_type);
103
104    if !status.is_client_error() && !status.is_server_error() {
105        let content = resp.text().await?;
106        match content_type {
107            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
108            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepairTaskUpdateInfo`"))),
109            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepairTaskUpdateInfo`")))),
110        }
111    } else {
112        let content = resp.text().await?;
113        let entity: Option<CancelRepairTaskError> = serde_json::from_str(&content).ok();
114        Err(Error::ResponseError(ResponseContent {
115            status,
116            content,
117            entity,
118        }))
119    }
120}
121
122/// For clusters that have the Repair Manager Service configured, this API provides a way to create repair tasks that run automatically or manually. For repair tasks that run automatically, an appropriate repair executor must be running for each repair action to run automatically. These are currently only available in specially-configured Azure Cloud Services.  To create a manual repair task, provide the set of impacted node names and the expected impact. When the state of the created repair task changes to approved, you can safely perform repair actions on those nodes.  This API supports the Service Fabric platform; it is not meant to be used directly from your code.
123pub async fn create_repair_task(
124    configuration: &configuration::Configuration,
125    api_version: &str,
126    repair_task: models::RepairTask,
127) -> Result<models::RepairTaskUpdateInfo, Error<CreateRepairTaskError>> {
128    // add a prefix to parameters to efficiently prevent name collisions
129    let p_query_api_version = api_version;
130    let p_body_repair_task = repair_task;
131
132    let uri_str = format!("{}/$/CreateRepairTask", configuration.base_path);
133    let mut req_builder = configuration
134        .client
135        .request(reqwest::Method::POST, &uri_str);
136
137    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
138    if let Some(ref user_agent) = configuration.user_agent {
139        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
140    }
141    req_builder = req_builder.json(&p_body_repair_task);
142
143    let req = req_builder.build()?;
144    let resp = configuration.client.execute(req).await?;
145
146    let status = resp.status();
147    let content_type = resp
148        .headers()
149        .get("content-type")
150        .and_then(|v| v.to_str().ok())
151        .unwrap_or("application/octet-stream");
152    let content_type = super::ContentType::from(content_type);
153
154    if !status.is_client_error() && !status.is_server_error() {
155        let content = resp.text().await?;
156        match content_type {
157            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
158            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepairTaskUpdateInfo`"))),
159            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepairTaskUpdateInfo`")))),
160        }
161    } else {
162        let content = resp.text().await?;
163        let entity: Option<CreateRepairTaskError> = serde_json::from_str(&content).ok();
164        Err(Error::ResponseError(ResponseContent {
165            status,
166            content,
167            entity,
168        }))
169    }
170}
171
172/// This API supports the Service Fabric platform; it is not meant to be used directly from your code.
173pub async fn delete_repair_task(
174    configuration: &configuration::Configuration,
175    api_version: &str,
176    repair_task_delete_description: models::RepairTaskDeleteDescription,
177) -> Result<(), Error<DeleteRepairTaskError>> {
178    // add a prefix to parameters to efficiently prevent name collisions
179    let p_query_api_version = api_version;
180    let p_body_repair_task_delete_description = repair_task_delete_description;
181
182    let uri_str = format!("{}/$/DeleteRepairTask", configuration.base_path);
183    let mut req_builder = configuration
184        .client
185        .request(reqwest::Method::POST, &uri_str);
186
187    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
188    if let Some(ref user_agent) = configuration.user_agent {
189        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
190    }
191    req_builder = req_builder.json(&p_body_repair_task_delete_description);
192
193    let req = req_builder.build()?;
194    let resp = configuration.client.execute(req).await?;
195
196    let status = resp.status();
197
198    if !status.is_client_error() && !status.is_server_error() {
199        Ok(())
200    } else {
201        let content = resp.text().await?;
202        let entity: Option<DeleteRepairTaskError> = serde_json::from_str(&content).ok();
203        Err(Error::ResponseError(ResponseContent {
204            status,
205            content,
206            entity,
207        }))
208    }
209}
210
211/// This API supports the Service Fabric platform; it is not meant to be used directly from your code.
212pub async fn force_approve_repair_task(
213    configuration: &configuration::Configuration,
214    api_version: &str,
215    repair_task_approve_description: models::RepairTaskApproveDescription,
216) -> Result<models::RepairTaskUpdateInfo, Error<ForceApproveRepairTaskError>> {
217    // add a prefix to parameters to efficiently prevent name collisions
218    let p_query_api_version = api_version;
219    let p_body_repair_task_approve_description = repair_task_approve_description;
220
221    let uri_str = format!("{}/$/ForceApproveRepairTask", configuration.base_path);
222    let mut req_builder = configuration
223        .client
224        .request(reqwest::Method::POST, &uri_str);
225
226    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
227    if let Some(ref user_agent) = configuration.user_agent {
228        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
229    }
230    req_builder = req_builder.json(&p_body_repair_task_approve_description);
231
232    let req = req_builder.build()?;
233    let resp = configuration.client.execute(req).await?;
234
235    let status = resp.status();
236    let content_type = resp
237        .headers()
238        .get("content-type")
239        .and_then(|v| v.to_str().ok())
240        .unwrap_or("application/octet-stream");
241    let content_type = super::ContentType::from(content_type);
242
243    if !status.is_client_error() && !status.is_server_error() {
244        let content = resp.text().await?;
245        match content_type {
246            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
247            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepairTaskUpdateInfo`"))),
248            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepairTaskUpdateInfo`")))),
249        }
250    } else {
251        let content = resp.text().await?;
252        let entity: Option<ForceApproveRepairTaskError> = serde_json::from_str(&content).ok();
253        Err(Error::ResponseError(ResponseContent {
254            status,
255            content,
256            entity,
257        }))
258    }
259}
260
261/// This API supports the Service Fabric platform; it is not meant to be used directly from your code.
262pub async fn get_repair_task_list(
263    configuration: &configuration::Configuration,
264    api_version: &str,
265    task_id_filter: Option<&str>,
266    state_filter: Option<i32>,
267    executor_filter: Option<&str>,
268) -> Result<Vec<models::RepairTask>, Error<GetRepairTaskListError>> {
269    // add a prefix to parameters to efficiently prevent name collisions
270    let p_query_api_version = api_version;
271    let p_query_task_id_filter = task_id_filter;
272    let p_query_state_filter = state_filter;
273    let p_query_executor_filter = executor_filter;
274
275    let uri_str = format!("{}/$/GetRepairTaskList", configuration.base_path);
276    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
277
278    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
279    if let Some(ref param_value) = p_query_task_id_filter {
280        req_builder = req_builder.query(&[("TaskIdFilter", &param_value.to_string())]);
281    }
282    if let Some(ref param_value) = p_query_state_filter {
283        req_builder = req_builder.query(&[("StateFilter", &param_value.to_string())]);
284    }
285    if let Some(ref param_value) = p_query_executor_filter {
286        req_builder = req_builder.query(&[("ExecutorFilter", &param_value.to_string())]);
287    }
288    if let Some(ref user_agent) = configuration.user_agent {
289        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
290    }
291
292    let req = req_builder.build()?;
293    let resp = configuration.client.execute(req).await?;
294
295    let status = resp.status();
296    let content_type = resp
297        .headers()
298        .get("content-type")
299        .and_then(|v| v.to_str().ok())
300        .unwrap_or("application/octet-stream");
301    let content_type = super::ContentType::from(content_type);
302
303    if !status.is_client_error() && !status.is_server_error() {
304        let content = resp.text().await?;
305        match content_type {
306            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
307            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RepairTask&gt;`"))),
308            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RepairTask&gt;`")))),
309        }
310    } else {
311        let content = resp.text().await?;
312        let entity: Option<GetRepairTaskListError> = serde_json::from_str(&content).ok();
313        Err(Error::ResponseError(ResponseContent {
314            status,
315            content,
316            entity,
317        }))
318    }
319}
320
321/// This API supports the Service Fabric platform; it is not meant to be used directly from your code.
322pub async fn update_repair_execution_state(
323    configuration: &configuration::Configuration,
324    api_version: &str,
325    repair_task: models::RepairTask,
326) -> Result<models::RepairTaskUpdateInfo, Error<UpdateRepairExecutionStateError>> {
327    // add a prefix to parameters to efficiently prevent name collisions
328    let p_query_api_version = api_version;
329    let p_body_repair_task = repair_task;
330
331    let uri_str = format!("{}/$/UpdateRepairExecutionState", configuration.base_path);
332    let mut req_builder = configuration
333        .client
334        .request(reqwest::Method::POST, &uri_str);
335
336    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
337    if let Some(ref user_agent) = configuration.user_agent {
338        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
339    }
340    req_builder = req_builder.json(&p_body_repair_task);
341
342    let req = req_builder.build()?;
343    let resp = configuration.client.execute(req).await?;
344
345    let status = resp.status();
346    let content_type = resp
347        .headers()
348        .get("content-type")
349        .and_then(|v| v.to_str().ok())
350        .unwrap_or("application/octet-stream");
351    let content_type = super::ContentType::from(content_type);
352
353    if !status.is_client_error() && !status.is_server_error() {
354        let content = resp.text().await?;
355        match content_type {
356            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
357            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepairTaskUpdateInfo`"))),
358            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepairTaskUpdateInfo`")))),
359        }
360    } else {
361        let content = resp.text().await?;
362        let entity: Option<UpdateRepairExecutionStateError> = serde_json::from_str(&content).ok();
363        Err(Error::ResponseError(ResponseContent {
364            status,
365            content,
366            entity,
367        }))
368    }
369}
370
371/// This API supports the Service Fabric platform; it is not meant to be used directly from your code.
372pub async fn update_repair_task_health_policy(
373    configuration: &configuration::Configuration,
374    api_version: &str,
375    repair_task_update_health_policy_description: models::RepairTaskUpdateHealthPolicyDescription,
376) -> Result<models::RepairTaskUpdateInfo, Error<UpdateRepairTaskHealthPolicyError>> {
377    // add a prefix to parameters to efficiently prevent name collisions
378    let p_query_api_version = api_version;
379    let p_body_repair_task_update_health_policy_description =
380        repair_task_update_health_policy_description;
381
382    let uri_str = format!("{}/$/UpdateRepairTaskHealthPolicy", configuration.base_path);
383    let mut req_builder = configuration
384        .client
385        .request(reqwest::Method::POST, &uri_str);
386
387    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
388    if let Some(ref user_agent) = configuration.user_agent {
389        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
390    }
391    req_builder = req_builder.json(&p_body_repair_task_update_health_policy_description);
392
393    let req = req_builder.build()?;
394    let resp = configuration.client.execute(req).await?;
395
396    let status = resp.status();
397    let content_type = resp
398        .headers()
399        .get("content-type")
400        .and_then(|v| v.to_str().ok())
401        .unwrap_or("application/octet-stream");
402    let content_type = super::ContentType::from(content_type);
403
404    if !status.is_client_error() && !status.is_server_error() {
405        let content = resp.text().await?;
406        match content_type {
407            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
408            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepairTaskUpdateInfo`"))),
409            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepairTaskUpdateInfo`")))),
410        }
411    } else {
412        let content = resp.text().await?;
413        let entity: Option<UpdateRepairTaskHealthPolicyError> = serde_json::from_str(&content).ok();
414        Err(Error::ResponseError(ResponseContent {
415            status,
416            content,
417            entity,
418        }))
419    }
420}
openapi_service_fabric/apis/repair_management_api.rs

openapi_service_fabric/apis/
repair_management_api.rs
