clientapi_pve/apis/
nodes_storage_api.rs

1/*
2 * Proxmox Virtual Environment API
3 *
4 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pve.proxmox.com/pve-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_storage_copy`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum NodesStorageCopyError {
22    Status400(models::PveError),
23    Status401(models::PveError),
24    Status403(models::PveError),
25    Status404(models::PveError),
26    Status500(models::PveError),
27    Status501(models::PveError),
28    Status503(models::PveError),
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`nodes_storage_create_content`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum NodesStorageCreateContentError {
36    Status400(models::PveError),
37    Status401(models::PveError),
38    Status403(models::PveError),
39    Status404(models::PveError),
40    Status500(models::PveError),
41    Status501(models::PveError),
42    Status503(models::PveError),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`nodes_storage_delete_content`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum NodesStorageDeleteContentError {
50    Status400(models::PveError),
51    Status401(models::PveError),
52    Status403(models::PveError),
53    Status404(models::PveError),
54    Status500(models::PveError),
55    Status501(models::PveError),
56    Status503(models::PveError),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`nodes_storage_delete_prunebackups`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum NodesStorageDeletePrunebackupsError {
64    Status400(models::PveError),
65    Status401(models::PveError),
66    Status403(models::PveError),
67    Status404(models::PveError),
68    Status500(models::PveError),
69    Status501(models::PveError),
70    Status503(models::PveError),
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`nodes_storage_diridx`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum NodesStorageDiridxError {
78    Status400(models::PveError),
79    Status401(models::PveError),
80    Status403(models::PveError),
81    Status404(models::PveError),
82    Status500(models::PveError),
83    Status501(models::PveError),
84    Status503(models::PveError),
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`nodes_storage_download`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum NodesStorageDownloadError {
92    Status400(models::PveError),
93    Status401(models::PveError),
94    Status403(models::PveError),
95    Status404(models::PveError),
96    Status500(models::PveError),
97    Status501(models::PveError),
98    Status503(models::PveError),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`nodes_storage_download_url`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum NodesStorageDownloadUrlError {
106    Status400(models::PveError),
107    Status401(models::PveError),
108    Status403(models::PveError),
109    Status404(models::PveError),
110    Status500(models::PveError),
111    Status501(models::PveError),
112    Status503(models::PveError),
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`nodes_storage_dryrun`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum NodesStorageDryrunError {
120    Status400(models::PveError),
121    Status401(models::PveError),
122    Status403(models::PveError),
123    Status404(models::PveError),
124    Status500(models::PveError),
125    Status501(models::PveError),
126    Status503(models::PveError),
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`nodes_storage_get_content`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum NodesStorageGetContentError {
134    Status400(models::PveError),
135    Status401(models::PveError),
136    Status403(models::PveError),
137    Status404(models::PveError),
138    Status500(models::PveError),
139    Status501(models::PveError),
140    Status503(models::PveError),
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`nodes_storage_get_import_metadata`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum NodesStorageGetImportMetadataError {
148    Status400(models::PveError),
149    Status401(models::PveError),
150    Status403(models::PveError),
151    Status404(models::PveError),
152    Status500(models::PveError),
153    Status501(models::PveError),
154    Status503(models::PveError),
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`nodes_storage_get_list`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum NodesStorageGetListError {
162    Status400(models::PveError),
163    Status401(models::PveError),
164    Status403(models::PveError),
165    Status404(models::PveError),
166    Status500(models::PveError),
167    Status501(models::PveError),
168    Status503(models::PveError),
169    UnknownValue(serde_json::Value),
170}
171
172/// struct for typed errors of method [`nodes_storage_get_storage`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum NodesStorageGetStorageError {
176    Status400(models::PveError),
177    Status401(models::PveError),
178    Status403(models::PveError),
179    Status404(models::PveError),
180    Status500(models::PveError),
181    Status501(models::PveError),
182    Status503(models::PveError),
183    UnknownValue(serde_json::Value),
184}
185
186/// struct for typed errors of method [`nodes_storage_identity`]
187#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum NodesStorageIdentityError {
190    Status400(models::PveError),
191    Status401(models::PveError),
192    Status403(models::PveError),
193    Status404(models::PveError),
194    Status500(models::PveError),
195    Status501(models::PveError),
196    Status503(models::PveError),
197    UnknownValue(serde_json::Value),
198}
199
200/// struct for typed errors of method [`nodes_storage_info`]
201#[derive(Debug, Clone, Serialize, Deserialize)]
202#[serde(untagged)]
203pub enum NodesStorageInfoError {
204    Status400(models::PveError),
205    Status401(models::PveError),
206    Status403(models::PveError),
207    Status404(models::PveError),
208    Status500(models::PveError),
209    Status501(models::PveError),
210    Status503(models::PveError),
211    UnknownValue(serde_json::Value),
212}
213
214/// struct for typed errors of method [`nodes_storage_oci_registry_pull`]
215#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum NodesStorageOciRegistryPullError {
218    Status400(models::PveError),
219    Status401(models::PveError),
220    Status403(models::PveError),
221    Status404(models::PveError),
222    Status500(models::PveError),
223    Status501(models::PveError),
224    Status503(models::PveError),
225    UnknownValue(serde_json::Value),
226}
227
228/// struct for typed errors of method [`nodes_storage_read_status`]
229#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum NodesStorageReadStatusError {
232    Status400(models::PveError),
233    Status401(models::PveError),
234    Status403(models::PveError),
235    Status404(models::PveError),
236    Status500(models::PveError),
237    Status501(models::PveError),
238    Status503(models::PveError),
239    UnknownValue(serde_json::Value),
240}
241
242/// struct for typed errors of method [`nodes_storage_rrd`]
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum NodesStorageRrdError {
246    Status400(models::PveError),
247    Status401(models::PveError),
248    Status403(models::PveError),
249    Status404(models::PveError),
250    Status500(models::PveError),
251    Status501(models::PveError),
252    Status503(models::PveError),
253    UnknownValue(serde_json::Value),
254}
255
256/// struct for typed errors of method [`nodes_storage_rrddata`]
257#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum NodesStorageRrddataError {
260    Status400(models::PveError),
261    Status401(models::PveError),
262    Status403(models::PveError),
263    Status404(models::PveError),
264    Status500(models::PveError),
265    Status501(models::PveError),
266    Status503(models::PveError),
267    UnknownValue(serde_json::Value),
268}
269
270/// struct for typed errors of method [`nodes_storage_updateattributes`]
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(untagged)]
273pub enum NodesStorageUpdateattributesError {
274    Status400(models::PveError),
275    Status401(models::PveError),
276    Status403(models::PveError),
277    Status404(models::PveError),
278    Status500(models::PveError),
279    Status501(models::PveError),
280    Status503(models::PveError),
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`nodes_storage_upload`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum NodesStorageUploadError {
288    Status400(models::PveError),
289    Status401(models::PveError),
290    Status403(models::PveError),
291    Status404(models::PveError),
292    Status500(models::PveError),
293    Status501(models::PveError),
294    Status503(models::PveError),
295    UnknownValue(serde_json::Value),
296}
297
298
299/// Copy a volume. This is experimental code - do not use.
300pub async fn nodes_storage_copy(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str, nodes_storage_copy_request: models::NodesStorageCopyRequest) -> Result<models::NodesStorageCopyResponse, Error<NodesStorageCopyError>> {
301    // add a prefix to parameters to efficiently prevent name collisions
302    let p_path_node = node;
303    let p_path_storage = storage;
304    let p_path_volume = volume;
305    let p_body_nodes_storage_copy_request = nodes_storage_copy_request;
306
307    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content/{volume}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage), volume=crate::apis::urlencode(p_path_volume));
308    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
309
310    if let Some(ref user_agent) = configuration.user_agent {
311        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
312    }
313    if let Some(ref apikey) = configuration.api_key {
314        let key = apikey.key.clone();
315        let value = match apikey.prefix {
316            Some(ref prefix) => format!("{} {}", prefix, key),
317            None => key,
318        };
319        req_builder = req_builder.header("Authorization", value);
320    };
321    if let Some(ref apikey) = configuration.api_key {
322        let key = apikey.key.clone();
323        let value = match apikey.prefix {
324            Some(ref prefix) => format!("{} {}", prefix, key),
325            None => key,
326        };
327        req_builder = req_builder.header("CSRFPreventionToken", value);
328    };
329    req_builder = req_builder.json(&p_body_nodes_storage_copy_request);
330
331    let req = req_builder.build()?;
332    let resp = configuration.client.execute(req).await?;
333
334    let status = resp.status();
335    let content_type = resp
336        .headers()
337        .get("content-type")
338        .and_then(|v| v.to_str().ok())
339        .unwrap_or("application/octet-stream");
340    let content_type = super::ContentType::from(content_type);
341
342    if !status.is_client_error() && !status.is_server_error() {
343        let content = resp.text().await?;
344        match content_type {
345            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
346            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageCopyResponse`"))),
347            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::NodesStorageCopyResponse`")))),
348        }
349    } else {
350        let content = resp.text().await?;
351        let entity: Option<NodesStorageCopyError> = serde_json::from_str(&content).ok();
352        Err(Error::ResponseError(ResponseContent { status, content, entity }))
353    }
354}
355
356/// Allocate disk images.
357pub async fn nodes_storage_create_content(configuration: &configuration::Configuration, node: &str, storage: &str, nodes_storage_create_content_request: models::NodesStorageCreateContentRequest) -> Result<models::NodesStorageCreateContentResponse, Error<NodesStorageCreateContentError>> {
358    // add a prefix to parameters to efficiently prevent name collisions
359    let p_path_node = node;
360    let p_path_storage = storage;
361    let p_body_nodes_storage_create_content_request = nodes_storage_create_content_request;
362
363    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
364    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
365
366    if let Some(ref user_agent) = configuration.user_agent {
367        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
368    }
369    if let Some(ref apikey) = configuration.api_key {
370        let key = apikey.key.clone();
371        let value = match apikey.prefix {
372            Some(ref prefix) => format!("{} {}", prefix, key),
373            None => key,
374        };
375        req_builder = req_builder.header("Authorization", value);
376    };
377    if let Some(ref apikey) = configuration.api_key {
378        let key = apikey.key.clone();
379        let value = match apikey.prefix {
380            Some(ref prefix) => format!("{} {}", prefix, key),
381            None => key,
382        };
383        req_builder = req_builder.header("CSRFPreventionToken", value);
384    };
385    req_builder = req_builder.json(&p_body_nodes_storage_create_content_request);
386
387    let req = req_builder.build()?;
388    let resp = configuration.client.execute(req).await?;
389
390    let status = resp.status();
391    let content_type = resp
392        .headers()
393        .get("content-type")
394        .and_then(|v| v.to_str().ok())
395        .unwrap_or("application/octet-stream");
396    let content_type = super::ContentType::from(content_type);
397
398    if !status.is_client_error() && !status.is_server_error() {
399        let content = resp.text().await?;
400        match content_type {
401            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
402            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageCreateContentResponse`"))),
403            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::NodesStorageCreateContentResponse`")))),
404        }
405    } else {
406        let content = resp.text().await?;
407        let entity: Option<NodesStorageCreateContentError> = serde_json::from_str(&content).ok();
408        Err(Error::ResponseError(ResponseContent { status, content, entity }))
409    }
410}
411
412/// Delete volume  Permissions: You need 'Datastore.Allocate' privilege on the storage (or 'Datastore.AllocateSpace' for backup volumes if you have VM.Backup privilege on the VM).
413pub async fn nodes_storage_delete_content(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str, delay: Option<i32>) -> Result<models::NodesStorageDeleteContentResponse, Error<NodesStorageDeleteContentError>> {
414    // add a prefix to parameters to efficiently prevent name collisions
415    let p_path_node = node;
416    let p_path_storage = storage;
417    let p_path_volume = volume;
418    let p_query_delay = delay;
419
420    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content/{volume}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage), volume=crate::apis::urlencode(p_path_volume));
421    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
422
423    if let Some(ref param_value) = p_query_delay {
424        req_builder = req_builder.query(&[("delay", &param_value.to_string())]);
425    }
426    if let Some(ref user_agent) = configuration.user_agent {
427        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
428    }
429    if let Some(ref apikey) = configuration.api_key {
430        let key = apikey.key.clone();
431        let value = match apikey.prefix {
432            Some(ref prefix) => format!("{} {}", prefix, key),
433            None => key,
434        };
435        req_builder = req_builder.header("Authorization", value);
436    };
437    if let Some(ref apikey) = configuration.api_key {
438        let key = apikey.key.clone();
439        let value = match apikey.prefix {
440            Some(ref prefix) => format!("{} {}", prefix, key),
441            None => key,
442        };
443        req_builder = req_builder.header("CSRFPreventionToken", value);
444    };
445
446    let req = req_builder.build()?;
447    let resp = configuration.client.execute(req).await?;
448
449    let status = resp.status();
450    let content_type = resp
451        .headers()
452        .get("content-type")
453        .and_then(|v| v.to_str().ok())
454        .unwrap_or("application/octet-stream");
455    let content_type = super::ContentType::from(content_type);
456
457    if !status.is_client_error() && !status.is_server_error() {
458        let content = resp.text().await?;
459        match content_type {
460            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
461            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageDeleteContentResponse`"))),
462            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::NodesStorageDeleteContentResponse`")))),
463        }
464    } else {
465        let content = resp.text().await?;
466        let entity: Option<NodesStorageDeleteContentError> = serde_json::from_str(&content).ok();
467        Err(Error::ResponseError(ResponseContent { status, content, entity }))
468    }
469}
470
471/// Prune backups. Only those using the standard naming scheme are considered.  Permissions: You need the 'Datastore.Allocate' privilege on the storage (or if a VM ID is specified, 'Datastore.AllocateSpace' and 'VM.Backup' for the VM).
472pub async fn nodes_storage_delete_prunebackups(configuration: &configuration::Configuration, node: &str, storage: &str, prune_backups: Option<&str>, r#type: Option<models::PveClusterBackupInfoTypeEnum>, vmid: Option<i32>) -> Result<models::NodesStorageDeletePrunebackupsResponse, Error<NodesStorageDeletePrunebackupsError>> {
473    // add a prefix to parameters to efficiently prevent name collisions
474    let p_path_node = node;
475    let p_path_storage = storage;
476    let p_query_prune_backups = prune_backups;
477    let p_query_type = r#type;
478    let p_query_vmid = vmid;
479
480    let uri_str = format!("{}/nodes/{node}/storage/{storage}/prunebackups", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
481    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
482
483    if let Some(ref param_value) = p_query_prune_backups {
484        req_builder = req_builder.query(&[("prune-backups", &param_value.to_string())]);
485    }
486    if let Some(ref param_value) = p_query_type {
487        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
488    }
489    if let Some(ref param_value) = p_query_vmid {
490        req_builder = req_builder.query(&[("vmid", &param_value.to_string())]);
491    }
492    if let Some(ref user_agent) = configuration.user_agent {
493        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
494    }
495    if let Some(ref apikey) = configuration.api_key {
496        let key = apikey.key.clone();
497        let value = match apikey.prefix {
498            Some(ref prefix) => format!("{} {}", prefix, key),
499            None => key,
500        };
501        req_builder = req_builder.header("Authorization", value);
502    };
503    if let Some(ref apikey) = configuration.api_key {
504        let key = apikey.key.clone();
505        let value = match apikey.prefix {
506            Some(ref prefix) => format!("{} {}", prefix, key),
507            None => key,
508        };
509        req_builder = req_builder.header("CSRFPreventionToken", value);
510    };
511
512    let req = req_builder.build()?;
513    let resp = configuration.client.execute(req).await?;
514
515    let status = resp.status();
516    let content_type = resp
517        .headers()
518        .get("content-type")
519        .and_then(|v| v.to_str().ok())
520        .unwrap_or("application/octet-stream");
521    let content_type = super::ContentType::from(content_type);
522
523    if !status.is_client_error() && !status.is_server_error() {
524        let content = resp.text().await?;
525        match content_type {
526            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
527            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageDeletePrunebackupsResponse`"))),
528            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::NodesStorageDeletePrunebackupsResponse`")))),
529        }
530    } else {
531        let content = resp.text().await?;
532        let entity: Option<NodesStorageDeletePrunebackupsError> = serde_json::from_str(&content).ok();
533        Err(Error::ResponseError(ResponseContent { status, content, entity }))
534    }
535}
536
537/// 
538pub async fn nodes_storage_diridx(configuration: &configuration::Configuration, node: &str, storage: &str) -> Result<models::NodesStorageDiridxResponse, Error<NodesStorageDiridxError>> {
539    // add a prefix to parameters to efficiently prevent name collisions
540    let p_path_node = node;
541    let p_path_storage = storage;
542
543    let uri_str = format!("{}/nodes/{node}/storage/{storage}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
544    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
545
546    if let Some(ref user_agent) = configuration.user_agent {
547        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
548    }
549    if let Some(ref apikey) = configuration.api_key {
550        let key = apikey.key.clone();
551        let value = match apikey.prefix {
552            Some(ref prefix) => format!("{} {}", prefix, key),
553            None => key,
554        };
555        req_builder = req_builder.header("Authorization", value);
556    };
557    if let Some(ref apikey) = configuration.api_key {
558        let key = apikey.key.clone();
559        let value = match apikey.prefix {
560            Some(ref prefix) => format!("{} {}", prefix, key),
561            None => key,
562        };
563        req_builder = req_builder.header("CSRFPreventionToken", value);
564    };
565
566    let req = req_builder.build()?;
567    let resp = configuration.client.execute(req).await?;
568
569    let status = resp.status();
570    let content_type = resp
571        .headers()
572        .get("content-type")
573        .and_then(|v| v.to_str().ok())
574        .unwrap_or("application/octet-stream");
575    let content_type = super::ContentType::from(content_type);
576
577    if !status.is_client_error() && !status.is_server_error() {
578        let content = resp.text().await?;
579        match content_type {
580            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
581            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageDiridxResponse`"))),
582            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::NodesStorageDiridxResponse`")))),
583        }
584    } else {
585        let content = resp.text().await?;
586        let entity: Option<NodesStorageDiridxError> = serde_json::from_str(&content).ok();
587        Err(Error::ResponseError(ResponseContent { status, content, entity }))
588    }
589}
590
591/// Extract a file or directory (as zip archive) from a PBS backup.  Permissions: You need read access for the volume.
592pub async fn nodes_storage_download(configuration: &configuration::Configuration, filepath: &str, node: &str, storage: &str, volume: &str, tar: Option<&str>) -> Result<models::NodesStorageDownloadResponse, Error<NodesStorageDownloadError>> {
593    // add a prefix to parameters to efficiently prevent name collisions
594    let p_query_filepath = filepath;
595    let p_path_node = node;
596    let p_path_storage = storage;
597    let p_query_volume = volume;
598    let p_query_tar = tar;
599
600    let uri_str = format!("{}/nodes/{node}/storage/{storage}/file-restore/download", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
601    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
602
603    req_builder = req_builder.query(&[("filepath", &p_query_filepath.to_string())]);
604    if let Some(ref param_value) = p_query_tar {
605        req_builder = req_builder.query(&[("tar", &param_value.to_string())]);
606    }
607    req_builder = req_builder.query(&[("volume", &p_query_volume.to_string())]);
608    if let Some(ref user_agent) = configuration.user_agent {
609        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
610    }
611    if let Some(ref apikey) = configuration.api_key {
612        let key = apikey.key.clone();
613        let value = match apikey.prefix {
614            Some(ref prefix) => format!("{} {}", prefix, key),
615            None => key,
616        };
617        req_builder = req_builder.header("Authorization", value);
618    };
619    if let Some(ref apikey) = configuration.api_key {
620        let key = apikey.key.clone();
621        let value = match apikey.prefix {
622            Some(ref prefix) => format!("{} {}", prefix, key),
623            None => key,
624        };
625        req_builder = req_builder.header("CSRFPreventionToken", value);
626    };
627
628    let req = req_builder.build()?;
629    let resp = configuration.client.execute(req).await?;
630
631    let status = resp.status();
632    let content_type = resp
633        .headers()
634        .get("content-type")
635        .and_then(|v| v.to_str().ok())
636        .unwrap_or("application/octet-stream");
637    let content_type = super::ContentType::from(content_type);
638
639    if !status.is_client_error() && !status.is_server_error() {
640        let content = resp.text().await?;
641        match content_type {
642            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
643            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageDownloadResponse`"))),
644            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::NodesStorageDownloadResponse`")))),
645        }
646    } else {
647        let content = resp.text().await?;
648        let entity: Option<NodesStorageDownloadError> = serde_json::from_str(&content).ok();
649        Err(Error::ResponseError(ResponseContent { status, content, entity }))
650    }
651}
652
653/// Download templates, ISO images, OVAs and VM images by using an URL.  Permissions: Requires allocation access on the storage and as this allows one to probe the (local!) host network indirectly it also requires one of Sys.Modify on / (for backwards compatibility) or the newer Sys.AccessNetwork privilege on the node.
654pub async fn nodes_storage_download_url(configuration: &configuration::Configuration, node: &str, storage: &str, nodes_storage_download_url_request: models::NodesStorageDownloadUrlRequest) -> Result<models::NodesStorageDownloadUrlResponse, Error<NodesStorageDownloadUrlError>> {
655    // add a prefix to parameters to efficiently prevent name collisions
656    let p_path_node = node;
657    let p_path_storage = storage;
658    let p_body_nodes_storage_download_url_request = nodes_storage_download_url_request;
659
660    let uri_str = format!("{}/nodes/{node}/storage/{storage}/download-url", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
661    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
662
663    if let Some(ref user_agent) = configuration.user_agent {
664        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
665    }
666    if let Some(ref apikey) = configuration.api_key {
667        let key = apikey.key.clone();
668        let value = match apikey.prefix {
669            Some(ref prefix) => format!("{} {}", prefix, key),
670            None => key,
671        };
672        req_builder = req_builder.header("Authorization", value);
673    };
674    if let Some(ref apikey) = configuration.api_key {
675        let key = apikey.key.clone();
676        let value = match apikey.prefix {
677            Some(ref prefix) => format!("{} {}", prefix, key),
678            None => key,
679        };
680        req_builder = req_builder.header("CSRFPreventionToken", value);
681    };
682    req_builder = req_builder.json(&p_body_nodes_storage_download_url_request);
683
684    let req = req_builder.build()?;
685    let resp = configuration.client.execute(req).await?;
686
687    let status = resp.status();
688    let content_type = resp
689        .headers()
690        .get("content-type")
691        .and_then(|v| v.to_str().ok())
692        .unwrap_or("application/octet-stream");
693    let content_type = super::ContentType::from(content_type);
694
695    if !status.is_client_error() && !status.is_server_error() {
696        let content = resp.text().await?;
697        match content_type {
698            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
699            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageDownloadUrlResponse`"))),
700            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::NodesStorageDownloadUrlResponse`")))),
701        }
702    } else {
703        let content = resp.text().await?;
704        let entity: Option<NodesStorageDownloadUrlError> = serde_json::from_str(&content).ok();
705        Err(Error::ResponseError(ResponseContent { status, content, entity }))
706    }
707}
708
709/// Get prune information for backups. NOTE: this is only a preview and might not be what a subsequent prune call does if backups are removed/added in the meantime.
710pub async fn nodes_storage_dryrun(configuration: &configuration::Configuration, node: &str, storage: &str, prune_backups: Option<&str>, r#type: Option<models::PveClusterBackupInfoTypeEnum>, vmid: Option<i32>) -> Result<models::NodesStorageDryrunResponse, Error<NodesStorageDryrunError>> {
711    // add a prefix to parameters to efficiently prevent name collisions
712    let p_path_node = node;
713    let p_path_storage = storage;
714    let p_query_prune_backups = prune_backups;
715    let p_query_type = r#type;
716    let p_query_vmid = vmid;
717
718    let uri_str = format!("{}/nodes/{node}/storage/{storage}/prunebackups", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
719    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
720
721    if let Some(ref param_value) = p_query_prune_backups {
722        req_builder = req_builder.query(&[("prune-backups", &param_value.to_string())]);
723    }
724    if let Some(ref param_value) = p_query_type {
725        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
726    }
727    if let Some(ref param_value) = p_query_vmid {
728        req_builder = req_builder.query(&[("vmid", &param_value.to_string())]);
729    }
730    if let Some(ref user_agent) = configuration.user_agent {
731        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
732    }
733    if let Some(ref apikey) = configuration.api_key {
734        let key = apikey.key.clone();
735        let value = match apikey.prefix {
736            Some(ref prefix) => format!("{} {}", prefix, key),
737            None => key,
738        };
739        req_builder = req_builder.header("Authorization", value);
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("CSRFPreventionToken", value);
748    };
749
750    let req = req_builder.build()?;
751    let resp = configuration.client.execute(req).await?;
752
753    let status = resp.status();
754    let content_type = resp
755        .headers()
756        .get("content-type")
757        .and_then(|v| v.to_str().ok())
758        .unwrap_or("application/octet-stream");
759    let content_type = super::ContentType::from(content_type);
760
761    if !status.is_client_error() && !status.is_server_error() {
762        let content = resp.text().await?;
763        match content_type {
764            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
765            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageDryrunResponse`"))),
766            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::NodesStorageDryrunResponse`")))),
767        }
768    } else {
769        let content = resp.text().await?;
770        let entity: Option<NodesStorageDryrunError> = serde_json::from_str(&content).ok();
771        Err(Error::ResponseError(ResponseContent { status, content, entity }))
772    }
773}
774
775/// List storage content.
776pub async fn nodes_storage_get_content(configuration: &configuration::Configuration, node: &str, storage: &str, content: Option<&str>, vmid: Option<i32>) -> Result<models::NodesStorageGetContentResponse, Error<NodesStorageGetContentError>> {
777    // add a prefix to parameters to efficiently prevent name collisions
778    let p_path_node = node;
779    let p_path_storage = storage;
780    let p_query_content = content;
781    let p_query_vmid = vmid;
782
783    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
784    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
785
786    if let Some(ref param_value) = p_query_content {
787        req_builder = req_builder.query(&[("content", &param_value.to_string())]);
788    }
789    if let Some(ref param_value) = p_query_vmid {
790        req_builder = req_builder.query(&[("vmid", &param_value.to_string())]);
791    }
792    if let Some(ref user_agent) = configuration.user_agent {
793        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
794    }
795    if let Some(ref apikey) = configuration.api_key {
796        let key = apikey.key.clone();
797        let value = match apikey.prefix {
798            Some(ref prefix) => format!("{} {}", prefix, key),
799            None => key,
800        };
801        req_builder = req_builder.header("Authorization", value);
802    };
803    if let Some(ref apikey) = configuration.api_key {
804        let key = apikey.key.clone();
805        let value = match apikey.prefix {
806            Some(ref prefix) => format!("{} {}", prefix, key),
807            None => key,
808        };
809        req_builder = req_builder.header("CSRFPreventionToken", value);
810    };
811
812    let req = req_builder.build()?;
813    let resp = configuration.client.execute(req).await?;
814
815    let status = resp.status();
816    let content_type = resp
817        .headers()
818        .get("content-type")
819        .and_then(|v| v.to_str().ok())
820        .unwrap_or("application/octet-stream");
821    let content_type = super::ContentType::from(content_type);
822
823    if !status.is_client_error() && !status.is_server_error() {
824        let content = resp.text().await?;
825        match content_type {
826            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
827            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageGetContentResponse`"))),
828            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::NodesStorageGetContentResponse`")))),
829        }
830    } else {
831        let content = resp.text().await?;
832        let entity: Option<NodesStorageGetContentError> = serde_json::from_str(&content).ok();
833        Err(Error::ResponseError(ResponseContent { status, content, entity }))
834    }
835}
836
837/// Get the base parameters for creating a guest which imports data from a foreign importable guest, like an ESXi VM  Permissions: You need read access for the volume.
838pub async fn nodes_storage_get_import_metadata(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str) -> Result<models::NodesStorageGetImportMetadataResponse, Error<NodesStorageGetImportMetadataError>> {
839    // add a prefix to parameters to efficiently prevent name collisions
840    let p_path_node = node;
841    let p_path_storage = storage;
842    let p_query_volume = volume;
843
844    let uri_str = format!("{}/nodes/{node}/storage/{storage}/import-metadata", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
845    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
846
847    req_builder = req_builder.query(&[("volume", &p_query_volume.to_string())]);
848    if let Some(ref user_agent) = configuration.user_agent {
849        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
850    }
851    if let Some(ref apikey) = configuration.api_key {
852        let key = apikey.key.clone();
853        let value = match apikey.prefix {
854            Some(ref prefix) => format!("{} {}", prefix, key),
855            None => key,
856        };
857        req_builder = req_builder.header("Authorization", value);
858    };
859    if let Some(ref apikey) = configuration.api_key {
860        let key = apikey.key.clone();
861        let value = match apikey.prefix {
862            Some(ref prefix) => format!("{} {}", prefix, key),
863            None => key,
864        };
865        req_builder = req_builder.header("CSRFPreventionToken", value);
866    };
867
868    let req = req_builder.build()?;
869    let resp = configuration.client.execute(req).await?;
870
871    let status = resp.status();
872    let content_type = resp
873        .headers()
874        .get("content-type")
875        .and_then(|v| v.to_str().ok())
876        .unwrap_or("application/octet-stream");
877    let content_type = super::ContentType::from(content_type);
878
879    if !status.is_client_error() && !status.is_server_error() {
880        let content = resp.text().await?;
881        match content_type {
882            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
883            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageGetImportMetadataResponse`"))),
884            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::NodesStorageGetImportMetadataResponse`")))),
885        }
886    } else {
887        let content = resp.text().await?;
888        let entity: Option<NodesStorageGetImportMetadataError> = serde_json::from_str(&content).ok();
889        Err(Error::ResponseError(ResponseContent { status, content, entity }))
890    }
891}
892
893/// List files and directories for single file restore under the given path.  Permissions: You need read access for the volume.
894pub async fn nodes_storage_get_list(configuration: &configuration::Configuration, filepath: &str, node: &str, storage: &str, volume: &str) -> Result<models::NodesStorageGetListResponse, Error<NodesStorageGetListError>> {
895    // add a prefix to parameters to efficiently prevent name collisions
896    let p_query_filepath = filepath;
897    let p_path_node = node;
898    let p_path_storage = storage;
899    let p_query_volume = volume;
900
901    let uri_str = format!("{}/nodes/{node}/storage/{storage}/file-restore/list", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
902    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
903
904    req_builder = req_builder.query(&[("filepath", &p_query_filepath.to_string())]);
905    req_builder = req_builder.query(&[("volume", &p_query_volume.to_string())]);
906    if let Some(ref user_agent) = configuration.user_agent {
907        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
908    }
909    if let Some(ref apikey) = configuration.api_key {
910        let key = apikey.key.clone();
911        let value = match apikey.prefix {
912            Some(ref prefix) => format!("{} {}", prefix, key),
913            None => key,
914        };
915        req_builder = req_builder.header("Authorization", value);
916    };
917    if let Some(ref apikey) = configuration.api_key {
918        let key = apikey.key.clone();
919        let value = match apikey.prefix {
920            Some(ref prefix) => format!("{} {}", prefix, key),
921            None => key,
922        };
923        req_builder = req_builder.header("CSRFPreventionToken", value);
924    };
925
926    let req = req_builder.build()?;
927    let resp = configuration.client.execute(req).await?;
928
929    let status = resp.status();
930    let content_type = resp
931        .headers()
932        .get("content-type")
933        .and_then(|v| v.to_str().ok())
934        .unwrap_or("application/octet-stream");
935    let content_type = super::ContentType::from(content_type);
936
937    if !status.is_client_error() && !status.is_server_error() {
938        let content = resp.text().await?;
939        match content_type {
940            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
941            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageGetListResponse`"))),
942            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::NodesStorageGetListResponse`")))),
943        }
944    } else {
945        let content = resp.text().await?;
946        let entity: Option<NodesStorageGetListError> = serde_json::from_str(&content).ok();
947        Err(Error::ResponseError(ResponseContent { status, content, entity }))
948    }
949}
950
951/// Get status for all datastores.  Permissions: Only list entries where you have 'Datastore.Audit' or 'Datastore.AllocateSpace' permissions on '/storage/<storage>'
952pub async fn nodes_storage_get_storage(configuration: &configuration::Configuration, node: &str, content: Option<&str>, enabled: Option<&str>, format: Option<&str>, storage: Option<&str>, target: Option<&str>) -> Result<models::NodesStorageGetStorageResponse, Error<NodesStorageGetStorageError>> {
953    // add a prefix to parameters to efficiently prevent name collisions
954    let p_path_node = node;
955    let p_query_content = content;
956    let p_query_enabled = enabled;
957    let p_query_format = format;
958    let p_query_storage = storage;
959    let p_query_target = target;
960
961    let uri_str = format!("{}/nodes/{node}/storage", configuration.base_path, node=crate::apis::urlencode(p_path_node));
962    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
963
964    if let Some(ref param_value) = p_query_content {
965        req_builder = req_builder.query(&[("content", &param_value.to_string())]);
966    }
967    if let Some(ref param_value) = p_query_enabled {
968        req_builder = req_builder.query(&[("enabled", &param_value.to_string())]);
969    }
970    if let Some(ref param_value) = p_query_format {
971        req_builder = req_builder.query(&[("format", &param_value.to_string())]);
972    }
973    if let Some(ref param_value) = p_query_storage {
974        req_builder = req_builder.query(&[("storage", &param_value.to_string())]);
975    }
976    if let Some(ref param_value) = p_query_target {
977        req_builder = req_builder.query(&[("target", &param_value.to_string())]);
978    }
979    if let Some(ref user_agent) = configuration.user_agent {
980        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
981    }
982    if let Some(ref apikey) = configuration.api_key {
983        let key = apikey.key.clone();
984        let value = match apikey.prefix {
985            Some(ref prefix) => format!("{} {}", prefix, key),
986            None => key,
987        };
988        req_builder = req_builder.header("Authorization", value);
989    };
990    if let Some(ref apikey) = configuration.api_key {
991        let key = apikey.key.clone();
992        let value = match apikey.prefix {
993            Some(ref prefix) => format!("{} {}", prefix, key),
994            None => key,
995        };
996        req_builder = req_builder.header("CSRFPreventionToken", value);
997    };
998
999    let req = req_builder.build()?;
1000    let resp = configuration.client.execute(req).await?;
1001
1002    let status = resp.status();
1003    let content_type = resp
1004        .headers()
1005        .get("content-type")
1006        .and_then(|v| v.to_str().ok())
1007        .unwrap_or("application/octet-stream");
1008    let content_type = super::ContentType::from(content_type);
1009
1010    if !status.is_client_error() && !status.is_server_error() {
1011        let content = resp.text().await?;
1012        match content_type {
1013            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1014            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageGetStorageResponse`"))),
1015            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::NodesStorageGetStorageResponse`")))),
1016        }
1017    } else {
1018        let content = resp.text().await?;
1019        let entity: Option<NodesStorageGetStorageError> = serde_json::from_str(&content).ok();
1020        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1021    }
1022}
1023
1024/// Return identity information for this storage instance.
1025pub async fn nodes_storage_identity(configuration: &configuration::Configuration, node: &str, storage: &str) -> Result<models::NodesStorageIdentityResponse, Error<NodesStorageIdentityError>> {
1026    // add a prefix to parameters to efficiently prevent name collisions
1027    let p_path_node = node;
1028    let p_path_storage = storage;
1029
1030    let uri_str = format!("{}/nodes/{node}/storage/{storage}/identity", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
1031    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1032
1033    if let Some(ref user_agent) = configuration.user_agent {
1034        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1035    }
1036    if let Some(ref apikey) = configuration.api_key {
1037        let key = apikey.key.clone();
1038        let value = match apikey.prefix {
1039            Some(ref prefix) => format!("{} {}", prefix, key),
1040            None => key,
1041        };
1042        req_builder = req_builder.header("Authorization", value);
1043    };
1044    if let Some(ref apikey) = configuration.api_key {
1045        let key = apikey.key.clone();
1046        let value = match apikey.prefix {
1047            Some(ref prefix) => format!("{} {}", prefix, key),
1048            None => key,
1049        };
1050        req_builder = req_builder.header("CSRFPreventionToken", value);
1051    };
1052
1053    let req = req_builder.build()?;
1054    let resp = configuration.client.execute(req).await?;
1055
1056    let status = resp.status();
1057    let content_type = resp
1058        .headers()
1059        .get("content-type")
1060        .and_then(|v| v.to_str().ok())
1061        .unwrap_or("application/octet-stream");
1062    let content_type = super::ContentType::from(content_type);
1063
1064    if !status.is_client_error() && !status.is_server_error() {
1065        let content = resp.text().await?;
1066        match content_type {
1067            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1068            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageIdentityResponse`"))),
1069            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::NodesStorageIdentityResponse`")))),
1070        }
1071    } else {
1072        let content = resp.text().await?;
1073        let entity: Option<NodesStorageIdentityError> = serde_json::from_str(&content).ok();
1074        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1075    }
1076}
1077
1078/// Get volume attributes  Permissions: You need read access for the volume.
1079pub async fn nodes_storage_info(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str) -> Result<models::NodesStorageInfoResponse, Error<NodesStorageInfoError>> {
1080    // add a prefix to parameters to efficiently prevent name collisions
1081    let p_path_node = node;
1082    let p_path_storage = storage;
1083    let p_path_volume = volume;
1084
1085    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content/{volume}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage), volume=crate::apis::urlencode(p_path_volume));
1086    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1087
1088    if let Some(ref user_agent) = configuration.user_agent {
1089        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1090    }
1091    if let Some(ref apikey) = configuration.api_key {
1092        let key = apikey.key.clone();
1093        let value = match apikey.prefix {
1094            Some(ref prefix) => format!("{} {}", prefix, key),
1095            None => key,
1096        };
1097        req_builder = req_builder.header("Authorization", value);
1098    };
1099    if let Some(ref apikey) = configuration.api_key {
1100        let key = apikey.key.clone();
1101        let value = match apikey.prefix {
1102            Some(ref prefix) => format!("{} {}", prefix, key),
1103            None => key,
1104        };
1105        req_builder = req_builder.header("CSRFPreventionToken", value);
1106    };
1107
1108    let req = req_builder.build()?;
1109    let resp = configuration.client.execute(req).await?;
1110
1111    let status = resp.status();
1112    let content_type = resp
1113        .headers()
1114        .get("content-type")
1115        .and_then(|v| v.to_str().ok())
1116        .unwrap_or("application/octet-stream");
1117    let content_type = super::ContentType::from(content_type);
1118
1119    if !status.is_client_error() && !status.is_server_error() {
1120        let content = resp.text().await?;
1121        match content_type {
1122            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1123            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageInfoResponse`"))),
1124            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::NodesStorageInfoResponse`")))),
1125        }
1126    } else {
1127        let content = resp.text().await?;
1128        let entity: Option<NodesStorageInfoError> = serde_json::from_str(&content).ok();
1129        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1130    }
1131}
1132
1133/// Pull an OCI image from a registry.
1134pub async fn nodes_storage_oci_registry_pull(configuration: &configuration::Configuration, node: &str, storage: &str, nodes_storage_oci_registry_pull_request: models::NodesStorageOciRegistryPullRequest) -> Result<models::NodesStorageOciRegistryPullResponse, Error<NodesStorageOciRegistryPullError>> {
1135    // add a prefix to parameters to efficiently prevent name collisions
1136    let p_path_node = node;
1137    let p_path_storage = storage;
1138    let p_body_nodes_storage_oci_registry_pull_request = nodes_storage_oci_registry_pull_request;
1139
1140    let uri_str = format!("{}/nodes/{node}/storage/{storage}/oci-registry-pull", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
1141    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1142
1143    if let Some(ref user_agent) = configuration.user_agent {
1144        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1145    }
1146    if let Some(ref apikey) = configuration.api_key {
1147        let key = apikey.key.clone();
1148        let value = match apikey.prefix {
1149            Some(ref prefix) => format!("{} {}", prefix, key),
1150            None => key,
1151        };
1152        req_builder = req_builder.header("Authorization", value);
1153    };
1154    if let Some(ref apikey) = configuration.api_key {
1155        let key = apikey.key.clone();
1156        let value = match apikey.prefix {
1157            Some(ref prefix) => format!("{} {}", prefix, key),
1158            None => key,
1159        };
1160        req_builder = req_builder.header("CSRFPreventionToken", value);
1161    };
1162    req_builder = req_builder.json(&p_body_nodes_storage_oci_registry_pull_request);
1163
1164    let req = req_builder.build()?;
1165    let resp = configuration.client.execute(req).await?;
1166
1167    let status = resp.status();
1168    let content_type = resp
1169        .headers()
1170        .get("content-type")
1171        .and_then(|v| v.to_str().ok())
1172        .unwrap_or("application/octet-stream");
1173    let content_type = super::ContentType::from(content_type);
1174
1175    if !status.is_client_error() && !status.is_server_error() {
1176        let content = resp.text().await?;
1177        match content_type {
1178            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1179            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageOciRegistryPullResponse`"))),
1180            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::NodesStorageOciRegistryPullResponse`")))),
1181        }
1182    } else {
1183        let content = resp.text().await?;
1184        let entity: Option<NodesStorageOciRegistryPullError> = serde_json::from_str(&content).ok();
1185        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1186    }
1187}
1188
1189/// Read storage status.
1190pub async fn nodes_storage_read_status(configuration: &configuration::Configuration, node: &str, storage: &str) -> Result<models::NodesStorageReadStatusResponse, Error<NodesStorageReadStatusError>> {
1191    // add a prefix to parameters to efficiently prevent name collisions
1192    let p_path_node = node;
1193    let p_path_storage = storage;
1194
1195    let uri_str = format!("{}/nodes/{node}/storage/{storage}/status", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
1196    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1197
1198    if let Some(ref user_agent) = configuration.user_agent {
1199        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1200    }
1201    if let Some(ref apikey) = configuration.api_key {
1202        let key = apikey.key.clone();
1203        let value = match apikey.prefix {
1204            Some(ref prefix) => format!("{} {}", prefix, key),
1205            None => key,
1206        };
1207        req_builder = req_builder.header("Authorization", value);
1208    };
1209    if let Some(ref apikey) = configuration.api_key {
1210        let key = apikey.key.clone();
1211        let value = match apikey.prefix {
1212            Some(ref prefix) => format!("{} {}", prefix, key),
1213            None => key,
1214        };
1215        req_builder = req_builder.header("CSRFPreventionToken", value);
1216    };
1217
1218    let req = req_builder.build()?;
1219    let resp = configuration.client.execute(req).await?;
1220
1221    let status = resp.status();
1222    let content_type = resp
1223        .headers()
1224        .get("content-type")
1225        .and_then(|v| v.to_str().ok())
1226        .unwrap_or("application/octet-stream");
1227    let content_type = super::ContentType::from(content_type);
1228
1229    if !status.is_client_error() && !status.is_server_error() {
1230        let content = resp.text().await?;
1231        match content_type {
1232            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1233            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageReadStatusResponse`"))),
1234            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::NodesStorageReadStatusResponse`")))),
1235        }
1236    } else {
1237        let content = resp.text().await?;
1238        let entity: Option<NodesStorageReadStatusError> = serde_json::from_str(&content).ok();
1239        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1240    }
1241}
1242
1243/// Read storage RRD statistics (returns PNG).
1244pub async fn nodes_storage_rrd(configuration: &configuration::Configuration, ds: &str, node: &str, storage: &str, timeframe: models::PveTimeframeEnum, cf: Option<models::PveCfEnum>) -> Result<models::NodesStorageRrdResponse, Error<NodesStorageRrdError>> {
1245    // add a prefix to parameters to efficiently prevent name collisions
1246    let p_query_ds = ds;
1247    let p_path_node = node;
1248    let p_path_storage = storage;
1249    let p_query_timeframe = timeframe;
1250    let p_query_cf = cf;
1251
1252    let uri_str = format!("{}/nodes/{node}/storage/{storage}/rrd", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
1253    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1254
1255    if let Some(ref param_value) = p_query_cf {
1256        req_builder = req_builder.query(&[("cf", &param_value.to_string())]);
1257    }
1258    req_builder = req_builder.query(&[("ds", &p_query_ds.to_string())]);
1259    req_builder = req_builder.query(&[("timeframe", &p_query_timeframe.to_string())]);
1260    if let Some(ref user_agent) = configuration.user_agent {
1261        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1262    }
1263    if let Some(ref apikey) = configuration.api_key {
1264        let key = apikey.key.clone();
1265        let value = match apikey.prefix {
1266            Some(ref prefix) => format!("{} {}", prefix, key),
1267            None => key,
1268        };
1269        req_builder = req_builder.header("Authorization", value);
1270    };
1271    if let Some(ref apikey) = configuration.api_key {
1272        let key = apikey.key.clone();
1273        let value = match apikey.prefix {
1274            Some(ref prefix) => format!("{} {}", prefix, key),
1275            None => key,
1276        };
1277        req_builder = req_builder.header("CSRFPreventionToken", value);
1278    };
1279
1280    let req = req_builder.build()?;
1281    let resp = configuration.client.execute(req).await?;
1282
1283    let status = resp.status();
1284    let content_type = resp
1285        .headers()
1286        .get("content-type")
1287        .and_then(|v| v.to_str().ok())
1288        .unwrap_or("application/octet-stream");
1289    let content_type = super::ContentType::from(content_type);
1290
1291    if !status.is_client_error() && !status.is_server_error() {
1292        let content = resp.text().await?;
1293        match content_type {
1294            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1295            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageRrdResponse`"))),
1296            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::NodesStorageRrdResponse`")))),
1297        }
1298    } else {
1299        let content = resp.text().await?;
1300        let entity: Option<NodesStorageRrdError> = serde_json::from_str(&content).ok();
1301        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1302    }
1303}
1304
1305/// Read storage RRD statistics.
1306pub async fn nodes_storage_rrddata(configuration: &configuration::Configuration, node: &str, storage: &str, timeframe: models::PveTimeframeEnum, cf: Option<models::PveCfEnum>) -> Result<models::NodesStorageRrddataResponse, Error<NodesStorageRrddataError>> {
1307    // add a prefix to parameters to efficiently prevent name collisions
1308    let p_path_node = node;
1309    let p_path_storage = storage;
1310    let p_query_timeframe = timeframe;
1311    let p_query_cf = cf;
1312
1313    let uri_str = format!("{}/nodes/{node}/storage/{storage}/rrddata", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
1314    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1315
1316    if let Some(ref param_value) = p_query_cf {
1317        req_builder = req_builder.query(&[("cf", &param_value.to_string())]);
1318    }
1319    req_builder = req_builder.query(&[("timeframe", &p_query_timeframe.to_string())]);
1320    if let Some(ref user_agent) = configuration.user_agent {
1321        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1322    }
1323    if let Some(ref apikey) = configuration.api_key {
1324        let key = apikey.key.clone();
1325        let value = match apikey.prefix {
1326            Some(ref prefix) => format!("{} {}", prefix, key),
1327            None => key,
1328        };
1329        req_builder = req_builder.header("Authorization", value);
1330    };
1331    if let Some(ref apikey) = configuration.api_key {
1332        let key = apikey.key.clone();
1333        let value = match apikey.prefix {
1334            Some(ref prefix) => format!("{} {}", prefix, key),
1335            None => key,
1336        };
1337        req_builder = req_builder.header("CSRFPreventionToken", value);
1338    };
1339
1340    let req = req_builder.build()?;
1341    let resp = configuration.client.execute(req).await?;
1342
1343    let status = resp.status();
1344    let content_type = resp
1345        .headers()
1346        .get("content-type")
1347        .and_then(|v| v.to_str().ok())
1348        .unwrap_or("application/octet-stream");
1349    let content_type = super::ContentType::from(content_type);
1350
1351    if !status.is_client_error() && !status.is_server_error() {
1352        let content = resp.text().await?;
1353        match content_type {
1354            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1355            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageRrddataResponse`"))),
1356            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::NodesStorageRrddataResponse`")))),
1357        }
1358    } else {
1359        let content = resp.text().await?;
1360        let entity: Option<NodesStorageRrddataError> = serde_json::from_str(&content).ok();
1361        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1362    }
1363}
1364
1365/// Update volume attributes  Permissions: You need read access for the volume.
1366pub async fn nodes_storage_updateattributes(configuration: &configuration::Configuration, node: &str, storage: &str, volume: &str, nodes_storage_updateattributes_request: Option<models::NodesStorageUpdateattributesRequest>) -> Result<models::NodesStorageUpdateattributesResponse, Error<NodesStorageUpdateattributesError>> {
1367    // add a prefix to parameters to efficiently prevent name collisions
1368    let p_path_node = node;
1369    let p_path_storage = storage;
1370    let p_path_volume = volume;
1371    let p_body_nodes_storage_updateattributes_request = nodes_storage_updateattributes_request;
1372
1373    let uri_str = format!("{}/nodes/{node}/storage/{storage}/content/{volume}", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage), volume=crate::apis::urlencode(p_path_volume));
1374    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
1375
1376    if let Some(ref user_agent) = configuration.user_agent {
1377        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1378    }
1379    if let Some(ref apikey) = configuration.api_key {
1380        let key = apikey.key.clone();
1381        let value = match apikey.prefix {
1382            Some(ref prefix) => format!("{} {}", prefix, key),
1383            None => key,
1384        };
1385        req_builder = req_builder.header("Authorization", value);
1386    };
1387    if let Some(ref apikey) = configuration.api_key {
1388        let key = apikey.key.clone();
1389        let value = match apikey.prefix {
1390            Some(ref prefix) => format!("{} {}", prefix, key),
1391            None => key,
1392        };
1393        req_builder = req_builder.header("CSRFPreventionToken", value);
1394    };
1395    req_builder = req_builder.json(&p_body_nodes_storage_updateattributes_request);
1396
1397    let req = req_builder.build()?;
1398    let resp = configuration.client.execute(req).await?;
1399
1400    let status = resp.status();
1401    let content_type = resp
1402        .headers()
1403        .get("content-type")
1404        .and_then(|v| v.to_str().ok())
1405        .unwrap_or("application/octet-stream");
1406    let content_type = super::ContentType::from(content_type);
1407
1408    if !status.is_client_error() && !status.is_server_error() {
1409        let content = resp.text().await?;
1410        match content_type {
1411            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1412            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageUpdateattributesResponse`"))),
1413            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::NodesStorageUpdateattributesResponse`")))),
1414        }
1415    } else {
1416        let content = resp.text().await?;
1417        let entity: Option<NodesStorageUpdateattributesError> = serde_json::from_str(&content).ok();
1418        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1419    }
1420}
1421
1422/// Upload templates, ISO images, OVAs and VM images.
1423pub async fn nodes_storage_upload(configuration: &configuration::Configuration, node: &str, storage: &str, nodes_storage_upload_request: models::NodesStorageUploadRequest) -> Result<models::NodesStorageUploadResponse, Error<NodesStorageUploadError>> {
1424    // add a prefix to parameters to efficiently prevent name collisions
1425    let p_path_node = node;
1426    let p_path_storage = storage;
1427    let p_body_nodes_storage_upload_request = nodes_storage_upload_request;
1428
1429    let uri_str = format!("{}/nodes/{node}/storage/{storage}/upload", configuration.base_path, node=crate::apis::urlencode(p_path_node), storage=crate::apis::urlencode(p_path_storage));
1430    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1431
1432    if let Some(ref user_agent) = configuration.user_agent {
1433        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1434    }
1435    if let Some(ref apikey) = configuration.api_key {
1436        let key = apikey.key.clone();
1437        let value = match apikey.prefix {
1438            Some(ref prefix) => format!("{} {}", prefix, key),
1439            None => key,
1440        };
1441        req_builder = req_builder.header("Authorization", value);
1442    };
1443    if let Some(ref apikey) = configuration.api_key {
1444        let key = apikey.key.clone();
1445        let value = match apikey.prefix {
1446            Some(ref prefix) => format!("{} {}", prefix, key),
1447            None => key,
1448        };
1449        req_builder = req_builder.header("CSRFPreventionToken", value);
1450    };
1451    req_builder = req_builder.json(&p_body_nodes_storage_upload_request);
1452
1453    let req = req_builder.build()?;
1454    let resp = configuration.client.execute(req).await?;
1455
1456    let status = resp.status();
1457    let content_type = resp
1458        .headers()
1459        .get("content-type")
1460        .and_then(|v| v.to_str().ok())
1461        .unwrap_or("application/octet-stream");
1462    let content_type = super::ContentType::from(content_type);
1463
1464    if !status.is_client_error() && !status.is_server_error() {
1465        let content = resp.text().await?;
1466        match content_type {
1467            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1468            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStorageUploadResponse`"))),
1469            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::NodesStorageUploadResponse`")))),
1470        }
1471    } else {
1472        let content = resp.text().await?;
1473        let entity: Option<NodesStorageUploadError> = serde_json::from_str(&content).ok();
1474        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1475    }
1476}
1477
clientapi_pve/apis/nodes_storage_api.rs

clientapi_pve/apis/
nodes_storage_api.rs
