clientapi_pbs/apis/
nodes_disks_api.rs

1/*
2 * Proxmox Backup Server API
3 *
4 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pbs.proxmox.com/docs/api-viewer/ for the upstream documentation.
5 *
6 * The version of the OpenAPI document: 9.x
7 * 
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`nodes_disks_create_directory`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum NodesDisksCreateDirectoryError {
22    Status400(models::PbsError),
23    Status401(models::PbsError),
24    Status403(models::PbsError),
25    Status404(models::PbsError),
26    Status500(models::PbsError),
27    Status501(models::PbsError),
28    Status503(models::PbsError),
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`nodes_disks_create_initgpt`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum NodesDisksCreateInitgptError {
36    Status400(models::PbsError),
37    Status401(models::PbsError),
38    Status403(models::PbsError),
39    Status404(models::PbsError),
40    Status500(models::PbsError),
41    Status501(models::PbsError),
42    Status503(models::PbsError),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`nodes_disks_create_zfs`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum NodesDisksCreateZfsError {
50    Status400(models::PbsError),
51    Status401(models::PbsError),
52    Status403(models::PbsError),
53    Status404(models::PbsError),
54    Status500(models::PbsError),
55    Status501(models::PbsError),
56    Status503(models::PbsError),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`nodes_disks_delete_directory`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum NodesDisksDeleteDirectoryError {
64    Status400(models::PbsError),
65    Status401(models::PbsError),
66    Status403(models::PbsError),
67    Status404(models::PbsError),
68    Status500(models::PbsError),
69    Status501(models::PbsError),
70    Status503(models::PbsError),
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`nodes_disks_get_directory`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum NodesDisksGetDirectoryError {
78    Status400(models::PbsError),
79    Status401(models::PbsError),
80    Status403(models::PbsError),
81    Status404(models::PbsError),
82    Status500(models::PbsError),
83    Status501(models::PbsError),
84    Status503(models::PbsError),
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`nodes_disks_get_disks`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum NodesDisksGetDisksError {
92    Status400(models::PbsError),
93    Status401(models::PbsError),
94    Status403(models::PbsError),
95    Status404(models::PbsError),
96    Status500(models::PbsError),
97    Status501(models::PbsError),
98    Status503(models::PbsError),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`nodes_disks_get_list`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum NodesDisksGetListError {
106    Status400(models::PbsError),
107    Status401(models::PbsError),
108    Status403(models::PbsError),
109    Status404(models::PbsError),
110    Status500(models::PbsError),
111    Status501(models::PbsError),
112    Status503(models::PbsError),
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`nodes_disks_get_nodes_by_node_disks_zfs_by_name`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum NodesDisksGetNodesByNodeDisksZfsByNameError {
120    Status400(models::PbsError),
121    Status401(models::PbsError),
122    Status403(models::PbsError),
123    Status404(models::PbsError),
124    Status500(models::PbsError),
125    Status501(models::PbsError),
126    Status503(models::PbsError),
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`nodes_disks_get_smart`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum NodesDisksGetSmartError {
134    Status400(models::PbsError),
135    Status401(models::PbsError),
136    Status403(models::PbsError),
137    Status404(models::PbsError),
138    Status500(models::PbsError),
139    Status501(models::PbsError),
140    Status503(models::PbsError),
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`nodes_disks_get_zfs`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum NodesDisksGetZfsError {
148    Status400(models::PbsError),
149    Status401(models::PbsError),
150    Status403(models::PbsError),
151    Status404(models::PbsError),
152    Status500(models::PbsError),
153    Status501(models::PbsError),
154    Status503(models::PbsError),
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`nodes_disks_update_wipedisk`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum NodesDisksUpdateWipediskError {
162    Status400(models::PbsError),
163    Status401(models::PbsError),
164    Status403(models::PbsError),
165    Status404(models::PbsError),
166    Status500(models::PbsError),
167    Status501(models::PbsError),
168    Status503(models::PbsError),
169    UnknownValue(serde_json::Value),
170}
171
172
173/// Create a Filesystem on an unused disk. Will be mounted under `/mnt/datastore/<name>`.
174pub async fn nodes_disks_create_directory(configuration: &configuration::Configuration, node: &str, nodes_disks_create_directory_request: models::NodesDisksCreateDirectoryRequest) -> Result<models::NodesDisksCreateDirectoryResponse, Error<NodesDisksCreateDirectoryError>> {
175    // add a prefix to parameters to efficiently prevent name collisions
176    let p_path_node = node;
177    let p_body_nodes_disks_create_directory_request = nodes_disks_create_directory_request;
178
179    let uri_str = format!("{}/nodes/{node}/disks/directory", configuration.base_path, node=crate::apis::urlencode(p_path_node));
180    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
181
182    if let Some(ref user_agent) = configuration.user_agent {
183        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
184    }
185    if let Some(ref apikey) = configuration.api_key {
186        let key = apikey.key.clone();
187        let value = match apikey.prefix {
188            Some(ref prefix) => format!("{} {}", prefix, key),
189            None => key,
190        };
191        req_builder = req_builder.header("Authorization", value);
192    };
193    if let Some(ref apikey) = configuration.api_key {
194        let key = apikey.key.clone();
195        let value = match apikey.prefix {
196            Some(ref prefix) => format!("{} {}", prefix, key),
197            None => key,
198        };
199        req_builder = req_builder.header("CSRFPreventionToken", value);
200    };
201    req_builder = req_builder.json(&p_body_nodes_disks_create_directory_request);
202
203    let req = req_builder.build()?;
204    let resp = configuration.client.execute(req).await?;
205
206    let status = resp.status();
207    let content_type = resp
208        .headers()
209        .get("content-type")
210        .and_then(|v| v.to_str().ok())
211        .unwrap_or("application/octet-stream");
212    let content_type = super::ContentType::from(content_type);
213
214    if !status.is_client_error() && !status.is_server_error() {
215        let content = resp.text().await?;
216        match content_type {
217            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
218            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksCreateDirectoryResponse`"))),
219            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::NodesDisksCreateDirectoryResponse`")))),
220        }
221    } else {
222        let content = resp.text().await?;
223        let entity: Option<NodesDisksCreateDirectoryError> = serde_json::from_str(&content).ok();
224        Err(Error::ResponseError(ResponseContent { status, content, entity }))
225    }
226}
227
228/// Initialize empty Disk with GPT
229pub async fn nodes_disks_create_initgpt(configuration: &configuration::Configuration, node: &str, nodes_disks_create_initgpt_request: models::NodesDisksCreateInitgptRequest) -> Result<models::NodesDisksCreateInitgptResponse, Error<NodesDisksCreateInitgptError>> {
230    // add a prefix to parameters to efficiently prevent name collisions
231    let p_path_node = node;
232    let p_body_nodes_disks_create_initgpt_request = nodes_disks_create_initgpt_request;
233
234    let uri_str = format!("{}/nodes/{node}/disks/initgpt", configuration.base_path, node=crate::apis::urlencode(p_path_node));
235    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
236
237    if let Some(ref user_agent) = configuration.user_agent {
238        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
239    }
240    if let Some(ref apikey) = configuration.api_key {
241        let key = apikey.key.clone();
242        let value = match apikey.prefix {
243            Some(ref prefix) => format!("{} {}", prefix, key),
244            None => key,
245        };
246        req_builder = req_builder.header("Authorization", value);
247    };
248    if let Some(ref apikey) = configuration.api_key {
249        let key = apikey.key.clone();
250        let value = match apikey.prefix {
251            Some(ref prefix) => format!("{} {}", prefix, key),
252            None => key,
253        };
254        req_builder = req_builder.header("CSRFPreventionToken", value);
255    };
256    req_builder = req_builder.json(&p_body_nodes_disks_create_initgpt_request);
257
258    let req = req_builder.build()?;
259    let resp = configuration.client.execute(req).await?;
260
261    let status = resp.status();
262    let content_type = resp
263        .headers()
264        .get("content-type")
265        .and_then(|v| v.to_str().ok())
266        .unwrap_or("application/octet-stream");
267    let content_type = super::ContentType::from(content_type);
268
269    if !status.is_client_error() && !status.is_server_error() {
270        let content = resp.text().await?;
271        match content_type {
272            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
273            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksCreateInitgptResponse`"))),
274            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::NodesDisksCreateInitgptResponse`")))),
275        }
276    } else {
277        let content = resp.text().await?;
278        let entity: Option<NodesDisksCreateInitgptError> = serde_json::from_str(&content).ok();
279        Err(Error::ResponseError(ResponseContent { status, content, entity }))
280    }
281}
282
283/// Create a new ZFS pool. Will be mounted under `/mnt/datastore/<name>`.
284pub async fn nodes_disks_create_zfs(configuration: &configuration::Configuration, node: &str, nodes_disks_create_zfs_request: models::NodesDisksCreateZfsRequest) -> Result<models::NodesDisksCreateZfsResponse, Error<NodesDisksCreateZfsError>> {
285    // add a prefix to parameters to efficiently prevent name collisions
286    let p_path_node = node;
287    let p_body_nodes_disks_create_zfs_request = nodes_disks_create_zfs_request;
288
289    let uri_str = format!("{}/nodes/{node}/disks/zfs", configuration.base_path, node=crate::apis::urlencode(p_path_node));
290    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
291
292    if let Some(ref user_agent) = configuration.user_agent {
293        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
294    }
295    if let Some(ref apikey) = configuration.api_key {
296        let key = apikey.key.clone();
297        let value = match apikey.prefix {
298            Some(ref prefix) => format!("{} {}", prefix, key),
299            None => key,
300        };
301        req_builder = req_builder.header("Authorization", value);
302    };
303    if let Some(ref apikey) = configuration.api_key {
304        let key = apikey.key.clone();
305        let value = match apikey.prefix {
306            Some(ref prefix) => format!("{} {}", prefix, key),
307            None => key,
308        };
309        req_builder = req_builder.header("CSRFPreventionToken", value);
310    };
311    req_builder = req_builder.json(&p_body_nodes_disks_create_zfs_request);
312
313    let req = req_builder.build()?;
314    let resp = configuration.client.execute(req).await?;
315
316    let status = resp.status();
317    let content_type = resp
318        .headers()
319        .get("content-type")
320        .and_then(|v| v.to_str().ok())
321        .unwrap_or("application/octet-stream");
322    let content_type = super::ContentType::from(content_type);
323
324    if !status.is_client_error() && !status.is_server_error() {
325        let content = resp.text().await?;
326        match content_type {
327            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
328            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksCreateZfsResponse`"))),
329            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::NodesDisksCreateZfsResponse`")))),
330        }
331    } else {
332        let content = resp.text().await?;
333        let entity: Option<NodesDisksCreateZfsError> = serde_json::from_str(&content).ok();
334        Err(Error::ResponseError(ResponseContent { status, content, entity }))
335    }
336}
337
338/// Remove a Filesystem mounted under `/mnt/datastore/<name>`.
339pub async fn nodes_disks_delete_directory(configuration: &configuration::Configuration, name: &str, node: &str) -> Result<models::NodesDisksDeleteDirectoryResponse, Error<NodesDisksDeleteDirectoryError>> {
340    // add a prefix to parameters to efficiently prevent name collisions
341    let p_path_name = name;
342    let p_path_node = node;
343
344    let uri_str = format!("{}/nodes/{node}/disks/directory/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
345    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
346
347    if let Some(ref user_agent) = configuration.user_agent {
348        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
349    }
350    if let Some(ref apikey) = configuration.api_key {
351        let key = apikey.key.clone();
352        let value = match apikey.prefix {
353            Some(ref prefix) => format!("{} {}", prefix, key),
354            None => key,
355        };
356        req_builder = req_builder.header("Authorization", value);
357    };
358    if let Some(ref apikey) = configuration.api_key {
359        let key = apikey.key.clone();
360        let value = match apikey.prefix {
361            Some(ref prefix) => format!("{} {}", prefix, key),
362            None => key,
363        };
364        req_builder = req_builder.header("CSRFPreventionToken", value);
365    };
366
367    let req = req_builder.build()?;
368    let resp = configuration.client.execute(req).await?;
369
370    let status = resp.status();
371    let content_type = resp
372        .headers()
373        .get("content-type")
374        .and_then(|v| v.to_str().ok())
375        .unwrap_or("application/octet-stream");
376    let content_type = super::ContentType::from(content_type);
377
378    if !status.is_client_error() && !status.is_server_error() {
379        let content = resp.text().await?;
380        match content_type {
381            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
382            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksDeleteDirectoryResponse`"))),
383            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::NodesDisksDeleteDirectoryResponse`")))),
384        }
385    } else {
386        let content = resp.text().await?;
387        let entity: Option<NodesDisksDeleteDirectoryError> = serde_json::from_str(&content).ok();
388        Err(Error::ResponseError(ResponseContent { status, content, entity }))
389    }
390}
391
392/// List systemd datastore mount units.
393pub async fn nodes_disks_get_directory(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesDisksGetDirectoryResponse, Error<NodesDisksGetDirectoryError>> {
394    // add a prefix to parameters to efficiently prevent name collisions
395    let p_path_node = node;
396
397    let uri_str = format!("{}/nodes/{node}/disks/directory", configuration.base_path, node=crate::apis::urlencode(p_path_node));
398    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
399
400    if let Some(ref user_agent) = configuration.user_agent {
401        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
402    }
403    if let Some(ref apikey) = configuration.api_key {
404        let key = apikey.key.clone();
405        let value = match apikey.prefix {
406            Some(ref prefix) => format!("{} {}", prefix, key),
407            None => key,
408        };
409        req_builder = req_builder.header("Authorization", value);
410    };
411    if let Some(ref apikey) = configuration.api_key {
412        let key = apikey.key.clone();
413        let value = match apikey.prefix {
414            Some(ref prefix) => format!("{} {}", prefix, key),
415            None => key,
416        };
417        req_builder = req_builder.header("CSRFPreventionToken", value);
418    };
419
420    let req = req_builder.build()?;
421    let resp = configuration.client.execute(req).await?;
422
423    let status = resp.status();
424    let content_type = resp
425        .headers()
426        .get("content-type")
427        .and_then(|v| v.to_str().ok())
428        .unwrap_or("application/octet-stream");
429    let content_type = super::ContentType::from(content_type);
430
431    if !status.is_client_error() && !status.is_server_error() {
432        let content = resp.text().await?;
433        match content_type {
434            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
435            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksGetDirectoryResponse`"))),
436            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::NodesDisksGetDirectoryResponse`")))),
437        }
438    } else {
439        let content = resp.text().await?;
440        let entity: Option<NodesDisksGetDirectoryError> = serde_json::from_str(&content).ok();
441        Err(Error::ResponseError(ResponseContent { status, content, entity }))
442    }
443}
444
445/// Directory index.
446pub async fn nodes_disks_get_disks(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesDisksGetDisksResponse, Error<NodesDisksGetDisksError>> {
447    // add a prefix to parameters to efficiently prevent name collisions
448    let p_path_node = node;
449
450    let uri_str = format!("{}/nodes/{node}/disks", configuration.base_path, node=crate::apis::urlencode(p_path_node));
451    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
452
453    if let Some(ref user_agent) = configuration.user_agent {
454        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
455    }
456    if let Some(ref apikey) = configuration.api_key {
457        let key = apikey.key.clone();
458        let value = match apikey.prefix {
459            Some(ref prefix) => format!("{} {}", prefix, key),
460            None => key,
461        };
462        req_builder = req_builder.header("Authorization", value);
463    };
464    if let Some(ref apikey) = configuration.api_key {
465        let key = apikey.key.clone();
466        let value = match apikey.prefix {
467            Some(ref prefix) => format!("{} {}", prefix, key),
468            None => key,
469        };
470        req_builder = req_builder.header("CSRFPreventionToken", value);
471    };
472
473    let req = req_builder.build()?;
474    let resp = configuration.client.execute(req).await?;
475
476    let status = resp.status();
477    let content_type = resp
478        .headers()
479        .get("content-type")
480        .and_then(|v| v.to_str().ok())
481        .unwrap_or("application/octet-stream");
482    let content_type = super::ContentType::from(content_type);
483
484    if !status.is_client_error() && !status.is_server_error() {
485        let content = resp.text().await?;
486        match content_type {
487            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
488            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksGetDisksResponse`"))),
489            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::NodesDisksGetDisksResponse`")))),
490        }
491    } else {
492        let content = resp.text().await?;
493        let entity: Option<NodesDisksGetDisksError> = serde_json::from_str(&content).ok();
494        Err(Error::ResponseError(ResponseContent { status, content, entity }))
495    }
496}
497
498/// List local disks
499pub async fn nodes_disks_get_list(configuration: &configuration::Configuration, node: &str, include_partitions: Option<bool>, skipsmart: Option<bool>, usage_type: Option<models::PbsUsageTypeEnum>) -> Result<models::NodesDisksGetListResponse, Error<NodesDisksGetListError>> {
500    // add a prefix to parameters to efficiently prevent name collisions
501    let p_path_node = node;
502    let p_query_include_partitions = include_partitions;
503    let p_query_skipsmart = skipsmart;
504    let p_query_usage_type = usage_type;
505
506    let uri_str = format!("{}/nodes/{node}/disks/list", configuration.base_path, node=crate::apis::urlencode(p_path_node));
507    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
508
509    if let Some(ref param_value) = p_query_include_partitions {
510        req_builder = req_builder.query(&[("include-partitions", &param_value.to_string())]);
511    }
512    if let Some(ref param_value) = p_query_skipsmart {
513        req_builder = req_builder.query(&[("skipsmart", &param_value.to_string())]);
514    }
515    if let Some(ref param_value) = p_query_usage_type {
516        req_builder = req_builder.query(&[("usage-type", &param_value.to_string())]);
517    }
518    if let Some(ref user_agent) = configuration.user_agent {
519        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
520    }
521    if let Some(ref apikey) = configuration.api_key {
522        let key = apikey.key.clone();
523        let value = match apikey.prefix {
524            Some(ref prefix) => format!("{} {}", prefix, key),
525            None => key,
526        };
527        req_builder = req_builder.header("Authorization", value);
528    };
529    if let Some(ref apikey) = configuration.api_key {
530        let key = apikey.key.clone();
531        let value = match apikey.prefix {
532            Some(ref prefix) => format!("{} {}", prefix, key),
533            None => key,
534        };
535        req_builder = req_builder.header("CSRFPreventionToken", value);
536    };
537
538    let req = req_builder.build()?;
539    let resp = configuration.client.execute(req).await?;
540
541    let status = resp.status();
542    let content_type = resp
543        .headers()
544        .get("content-type")
545        .and_then(|v| v.to_str().ok())
546        .unwrap_or("application/octet-stream");
547    let content_type = super::ContentType::from(content_type);
548
549    if !status.is_client_error() && !status.is_server_error() {
550        let content = resp.text().await?;
551        match content_type {
552            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
553            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksGetListResponse`"))),
554            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::NodesDisksGetListResponse`")))),
555        }
556    } else {
557        let content = resp.text().await?;
558        let entity: Option<NodesDisksGetListError> = serde_json::from_str(&content).ok();
559        Err(Error::ResponseError(ResponseContent { status, content, entity }))
560    }
561}
562
563/// Get zpool status details.
564pub async fn nodes_disks_get_nodes_by_node_disks_zfs_by_name(configuration: &configuration::Configuration, name: &str, node: &str) -> Result<models::NodesDisksGetNodesByNodeDisksZfsByNameResponse, Error<NodesDisksGetNodesByNodeDisksZfsByNameError>> {
565    // add a prefix to parameters to efficiently prevent name collisions
566    let p_path_name = name;
567    let p_path_node = node;
568
569    let uri_str = format!("{}/nodes/{node}/disks/zfs/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
570    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
571
572    if let Some(ref user_agent) = configuration.user_agent {
573        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
574    }
575    if let Some(ref apikey) = configuration.api_key {
576        let key = apikey.key.clone();
577        let value = match apikey.prefix {
578            Some(ref prefix) => format!("{} {}", prefix, key),
579            None => key,
580        };
581        req_builder = req_builder.header("Authorization", value);
582    };
583    if let Some(ref apikey) = configuration.api_key {
584        let key = apikey.key.clone();
585        let value = match apikey.prefix {
586            Some(ref prefix) => format!("{} {}", prefix, key),
587            None => key,
588        };
589        req_builder = req_builder.header("CSRFPreventionToken", value);
590    };
591
592    let req = req_builder.build()?;
593    let resp = configuration.client.execute(req).await?;
594
595    let status = resp.status();
596    let content_type = resp
597        .headers()
598        .get("content-type")
599        .and_then(|v| v.to_str().ok())
600        .unwrap_or("application/octet-stream");
601    let content_type = super::ContentType::from(content_type);
602
603    if !status.is_client_error() && !status.is_server_error() {
604        let content = resp.text().await?;
605        match content_type {
606            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
607            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksGetNodesByNodeDisksZfsByNameResponse`"))),
608            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::NodesDisksGetNodesByNodeDisksZfsByNameResponse`")))),
609        }
610    } else {
611        let content = resp.text().await?;
612        let entity: Option<NodesDisksGetNodesByNodeDisksZfsByNameError> = serde_json::from_str(&content).ok();
613        Err(Error::ResponseError(ResponseContent { status, content, entity }))
614    }
615}
616
617/// Get SMART attributes and health of a disk.
618pub async fn nodes_disks_get_smart(configuration: &configuration::Configuration, disk: &str, node: &str, healthonly: Option<bool>) -> Result<models::NodesDisksGetSmartResponse, Error<NodesDisksGetSmartError>> {
619    // add a prefix to parameters to efficiently prevent name collisions
620    let p_query_disk = disk;
621    let p_path_node = node;
622    let p_query_healthonly = healthonly;
623
624    let uri_str = format!("{}/nodes/{node}/disks/smart", configuration.base_path, node=crate::apis::urlencode(p_path_node));
625    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
626
627    req_builder = req_builder.query(&[("disk", &p_query_disk.to_string())]);
628    if let Some(ref param_value) = p_query_healthonly {
629        req_builder = req_builder.query(&[("healthonly", &param_value.to_string())]);
630    }
631    if let Some(ref user_agent) = configuration.user_agent {
632        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
633    }
634    if let Some(ref apikey) = configuration.api_key {
635        let key = apikey.key.clone();
636        let value = match apikey.prefix {
637            Some(ref prefix) => format!("{} {}", prefix, key),
638            None => key,
639        };
640        req_builder = req_builder.header("Authorization", value);
641    };
642    if let Some(ref apikey) = configuration.api_key {
643        let key = apikey.key.clone();
644        let value = match apikey.prefix {
645            Some(ref prefix) => format!("{} {}", prefix, key),
646            None => key,
647        };
648        req_builder = req_builder.header("CSRFPreventionToken", value);
649    };
650
651    let req = req_builder.build()?;
652    let resp = configuration.client.execute(req).await?;
653
654    let status = resp.status();
655    let content_type = resp
656        .headers()
657        .get("content-type")
658        .and_then(|v| v.to_str().ok())
659        .unwrap_or("application/octet-stream");
660    let content_type = super::ContentType::from(content_type);
661
662    if !status.is_client_error() && !status.is_server_error() {
663        let content = resp.text().await?;
664        match content_type {
665            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
666            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksGetSmartResponse`"))),
667            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::NodesDisksGetSmartResponse`")))),
668        }
669    } else {
670        let content = resp.text().await?;
671        let entity: Option<NodesDisksGetSmartError> = serde_json::from_str(&content).ok();
672        Err(Error::ResponseError(ResponseContent { status, content, entity }))
673    }
674}
675
676/// List zfs pools.
677pub async fn nodes_disks_get_zfs(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesDisksGetZfsResponse, Error<NodesDisksGetZfsError>> {
678    // add a prefix to parameters to efficiently prevent name collisions
679    let p_path_node = node;
680
681    let uri_str = format!("{}/nodes/{node}/disks/zfs", configuration.base_path, node=crate::apis::urlencode(p_path_node));
682    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
683
684    if let Some(ref user_agent) = configuration.user_agent {
685        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
686    }
687    if let Some(ref apikey) = configuration.api_key {
688        let key = apikey.key.clone();
689        let value = match apikey.prefix {
690            Some(ref prefix) => format!("{} {}", prefix, key),
691            None => key,
692        };
693        req_builder = req_builder.header("Authorization", value);
694    };
695    if let Some(ref apikey) = configuration.api_key {
696        let key = apikey.key.clone();
697        let value = match apikey.prefix {
698            Some(ref prefix) => format!("{} {}", prefix, key),
699            None => key,
700        };
701        req_builder = req_builder.header("CSRFPreventionToken", value);
702    };
703
704    let req = req_builder.build()?;
705    let resp = configuration.client.execute(req).await?;
706
707    let status = resp.status();
708    let content_type = resp
709        .headers()
710        .get("content-type")
711        .and_then(|v| v.to_str().ok())
712        .unwrap_or("application/octet-stream");
713    let content_type = super::ContentType::from(content_type);
714
715    if !status.is_client_error() && !status.is_server_error() {
716        let content = resp.text().await?;
717        match content_type {
718            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
719            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksGetZfsResponse`"))),
720            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::NodesDisksGetZfsResponse`")))),
721        }
722    } else {
723        let content = resp.text().await?;
724        let entity: Option<NodesDisksGetZfsError> = serde_json::from_str(&content).ok();
725        Err(Error::ResponseError(ResponseContent { status, content, entity }))
726    }
727}
728
729/// wipe disk
730pub async fn nodes_disks_update_wipedisk(configuration: &configuration::Configuration, node: &str, nodes_disks_update_wipedisk_request: models::NodesDisksUpdateWipediskRequest) -> Result<models::NodesDisksUpdateWipediskResponse, Error<NodesDisksUpdateWipediskError>> {
731    // add a prefix to parameters to efficiently prevent name collisions
732    let p_path_node = node;
733    let p_body_nodes_disks_update_wipedisk_request = nodes_disks_update_wipedisk_request;
734
735    let uri_str = format!("{}/nodes/{node}/disks/wipedisk", configuration.base_path, node=crate::apis::urlencode(p_path_node));
736    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
737
738    if let Some(ref user_agent) = configuration.user_agent {
739        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
740    }
741    if let Some(ref apikey) = configuration.api_key {
742        let key = apikey.key.clone();
743        let value = match apikey.prefix {
744            Some(ref prefix) => format!("{} {}", prefix, key),
745            None => key,
746        };
747        req_builder = req_builder.header("Authorization", value);
748    };
749    if let Some(ref apikey) = configuration.api_key {
750        let key = apikey.key.clone();
751        let value = match apikey.prefix {
752            Some(ref prefix) => format!("{} {}", prefix, key),
753            None => key,
754        };
755        req_builder = req_builder.header("CSRFPreventionToken", value);
756    };
757    req_builder = req_builder.json(&p_body_nodes_disks_update_wipedisk_request);
758
759    let req = req_builder.build()?;
760    let resp = configuration.client.execute(req).await?;
761
762    let status = resp.status();
763    let content_type = resp
764        .headers()
765        .get("content-type")
766        .and_then(|v| v.to_str().ok())
767        .unwrap_or("application/octet-stream");
768    let content_type = super::ContentType::from(content_type);
769
770    if !status.is_client_error() && !status.is_server_error() {
771        let content = resp.text().await?;
772        match content_type {
773            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
774            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesDisksUpdateWipediskResponse`"))),
775            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::NodesDisksUpdateWipediskResponse`")))),
776        }
777    } else {
778        let content = resp.text().await?;
779        let entity: Option<NodesDisksUpdateWipediskError> = serde_json::from_str(&content).ok();
780        Err(Error::ResponseError(ResponseContent { status, content, entity }))
781    }
782}
783
clientapi_pbs/apis/nodes_disks_api.rs

clientapi_pbs/apis/
nodes_disks_api.rs
