clientapi_pve/apis/
nodes_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_execute`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum NodesExecuteError {
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_get_nodes`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum NodesGetNodesError {
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_index_get_nodes`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum NodesIndexGetNodesError {
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_journal`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum NodesJournalError {
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_migrateall`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum NodesMigrateallError {
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_netstat`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum NodesNetstatError {
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_query_oci_repo_tags`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum NodesQueryOciRepoTagsError {
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_query_url_metadata`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum NodesQueryUrlMetadataError {
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_report`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum NodesReportError {
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_rrd`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum NodesRrdError {
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_rrddata`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum NodesRrddataError {
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_spiceshell`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum NodesSpiceshellError {
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_startall`]
187#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum NodesStartallError {
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_stopall`]
201#[derive(Debug, Clone, Serialize, Deserialize)]
202#[serde(untagged)]
203pub enum NodesStopallError {
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_suspendall`]
215#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum NodesSuspendallError {
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_syslog`]
229#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum NodesSyslogError {
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_termproxy`]
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum NodesTermproxyError {
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_version`]
257#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum NodesVersionError {
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_vncshell`]
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(untagged)]
273pub enum NodesVncshellError {
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_vncwebsocket`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum NodesVncwebsocketError {
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/// struct for typed errors of method [`nodes_wakeonlan`]
299#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum NodesWakeonlanError {
302    Status400(models::PveError),
303    Status401(models::PveError),
304    Status403(models::PveError),
305    Status404(models::PveError),
306    Status500(models::PveError),
307    Status501(models::PveError),
308    Status503(models::PveError),
309    UnknownValue(serde_json::Value),
310}
311
312
313/// Execute multiple commands in order, root only.
314pub async fn nodes_execute(configuration: &configuration::Configuration, node: &str, nodes_execute_request: models::NodesExecuteRequest) -> Result<models::NodesExecuteResponse, Error<NodesExecuteError>> {
315    // add a prefix to parameters to efficiently prevent name collisions
316    let p_path_node = node;
317    let p_body_nodes_execute_request = nodes_execute_request;
318
319    let uri_str = format!("{}/nodes/{node}/execute", configuration.base_path, node=crate::apis::urlencode(p_path_node));
320    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
321
322    if let Some(ref user_agent) = configuration.user_agent {
323        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
324    }
325    if let Some(ref apikey) = configuration.api_key {
326        let key = apikey.key.clone();
327        let value = match apikey.prefix {
328            Some(ref prefix) => format!("{} {}", prefix, key),
329            None => key,
330        };
331        req_builder = req_builder.header("Authorization", value);
332    };
333    if let Some(ref apikey) = configuration.api_key {
334        let key = apikey.key.clone();
335        let value = match apikey.prefix {
336            Some(ref prefix) => format!("{} {}", prefix, key),
337            None => key,
338        };
339        req_builder = req_builder.header("CSRFPreventionToken", value);
340    };
341    req_builder = req_builder.json(&p_body_nodes_execute_request);
342
343    let req = req_builder.build()?;
344    let resp = configuration.client.execute(req).await?;
345
346    let status = resp.status();
347    let content_type = resp
348        .headers()
349        .get("content-type")
350        .and_then(|v| v.to_str().ok())
351        .unwrap_or("application/octet-stream");
352    let content_type = super::ContentType::from(content_type);
353
354    if !status.is_client_error() && !status.is_server_error() {
355        let content = resp.text().await?;
356        match content_type {
357            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
358            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesExecuteResponse`"))),
359            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::NodesExecuteResponse`")))),
360        }
361    } else {
362        let content = resp.text().await?;
363        let entity: Option<NodesExecuteError> = serde_json::from_str(&content).ok();
364        Err(Error::ResponseError(ResponseContent { status, content, entity }))
365    }
366}
367
368/// Cluster node index.
369pub async fn nodes_get_nodes(configuration: &configuration::Configuration, ) -> Result<models::NodesGetNodesResponse, Error<NodesGetNodesError>> {
370
371    let uri_str = format!("{}/nodes", configuration.base_path);
372    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
373
374    if let Some(ref user_agent) = configuration.user_agent {
375        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
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("Authorization", value);
384    };
385    if let Some(ref apikey) = configuration.api_key {
386        let key = apikey.key.clone();
387        let value = match apikey.prefix {
388            Some(ref prefix) => format!("{} {}", prefix, key),
389            None => key,
390        };
391        req_builder = req_builder.header("CSRFPreventionToken", value);
392    };
393
394    let req = req_builder.build()?;
395    let resp = configuration.client.execute(req).await?;
396
397    let status = resp.status();
398    let content_type = resp
399        .headers()
400        .get("content-type")
401        .and_then(|v| v.to_str().ok())
402        .unwrap_or("application/octet-stream");
403    let content_type = super::ContentType::from(content_type);
404
405    if !status.is_client_error() && !status.is_server_error() {
406        let content = resp.text().await?;
407        match content_type {
408            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
409            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesGetNodesResponse`"))),
410            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::NodesGetNodesResponse`")))),
411        }
412    } else {
413        let content = resp.text().await?;
414        let entity: Option<NodesGetNodesError> = serde_json::from_str(&content).ok();
415        Err(Error::ResponseError(ResponseContent { status, content, entity }))
416    }
417}
418
419/// Node index.
420pub async fn nodes_index_get_nodes(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesIndexGetNodesResponse, Error<NodesIndexGetNodesError>> {
421    // add a prefix to parameters to efficiently prevent name collisions
422    let p_path_node = node;
423
424    let uri_str = format!("{}/nodes/{node}", configuration.base_path, node=crate::apis::urlencode(p_path_node));
425    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
426
427    if let Some(ref user_agent) = configuration.user_agent {
428        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
429    }
430    if let Some(ref apikey) = configuration.api_key {
431        let key = apikey.key.clone();
432        let value = match apikey.prefix {
433            Some(ref prefix) => format!("{} {}", prefix, key),
434            None => key,
435        };
436        req_builder = req_builder.header("Authorization", value);
437    };
438    if let Some(ref apikey) = configuration.api_key {
439        let key = apikey.key.clone();
440        let value = match apikey.prefix {
441            Some(ref prefix) => format!("{} {}", prefix, key),
442            None => key,
443        };
444        req_builder = req_builder.header("CSRFPreventionToken", value);
445    };
446
447    let req = req_builder.build()?;
448    let resp = configuration.client.execute(req).await?;
449
450    let status = resp.status();
451    let content_type = resp
452        .headers()
453        .get("content-type")
454        .and_then(|v| v.to_str().ok())
455        .unwrap_or("application/octet-stream");
456    let content_type = super::ContentType::from(content_type);
457
458    if !status.is_client_error() && !status.is_server_error() {
459        let content = resp.text().await?;
460        match content_type {
461            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
462            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesIndexGetNodesResponse`"))),
463            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::NodesIndexGetNodesResponse`")))),
464        }
465    } else {
466        let content = resp.text().await?;
467        let entity: Option<NodesIndexGetNodesError> = serde_json::from_str(&content).ok();
468        Err(Error::ResponseError(ResponseContent { status, content, entity }))
469    }
470}
471
472/// Read Journal
473pub async fn nodes_journal(configuration: &configuration::Configuration, node: &str, endcursor: Option<&str>, lastentries: Option<i64>, since: Option<i64>, startcursor: Option<&str>, until: Option<i64>) -> Result<models::NodesJournalResponse, Error<NodesJournalError>> {
474    // add a prefix to parameters to efficiently prevent name collisions
475    let p_path_node = node;
476    let p_query_endcursor = endcursor;
477    let p_query_lastentries = lastentries;
478    let p_query_since = since;
479    let p_query_startcursor = startcursor;
480    let p_query_until = until;
481
482    let uri_str = format!("{}/nodes/{node}/journal", configuration.base_path, node=crate::apis::urlencode(p_path_node));
483    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
484
485    if let Some(ref param_value) = p_query_endcursor {
486        req_builder = req_builder.query(&[("endcursor", &param_value.to_string())]);
487    }
488    if let Some(ref param_value) = p_query_lastentries {
489        req_builder = req_builder.query(&[("lastentries", &param_value.to_string())]);
490    }
491    if let Some(ref param_value) = p_query_since {
492        req_builder = req_builder.query(&[("since", &param_value.to_string())]);
493    }
494    if let Some(ref param_value) = p_query_startcursor {
495        req_builder = req_builder.query(&[("startcursor", &param_value.to_string())]);
496    }
497    if let Some(ref param_value) = p_query_until {
498        req_builder = req_builder.query(&[("until", &param_value.to_string())]);
499    }
500    if let Some(ref user_agent) = configuration.user_agent {
501        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
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("Authorization", value);
510    };
511    if let Some(ref apikey) = configuration.api_key {
512        let key = apikey.key.clone();
513        let value = match apikey.prefix {
514            Some(ref prefix) => format!("{} {}", prefix, key),
515            None => key,
516        };
517        req_builder = req_builder.header("CSRFPreventionToken", value);
518    };
519
520    let req = req_builder.build()?;
521    let resp = configuration.client.execute(req).await?;
522
523    let status = resp.status();
524    let content_type = resp
525        .headers()
526        .get("content-type")
527        .and_then(|v| v.to_str().ok())
528        .unwrap_or("application/octet-stream");
529    let content_type = super::ContentType::from(content_type);
530
531    if !status.is_client_error() && !status.is_server_error() {
532        let content = resp.text().await?;
533        match content_type {
534            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
535            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesJournalResponse`"))),
536            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::NodesJournalResponse`")))),
537        }
538    } else {
539        let content = resp.text().await?;
540        let entity: Option<NodesJournalError> = serde_json::from_str(&content).ok();
541        Err(Error::ResponseError(ResponseContent { status, content, entity }))
542    }
543}
544
545/// Migrate all VMs and Containers.  Permissions: The 'VM.Migrate' permission is required on '/' or on '/vms/<ID>' for each ID passed via the 'vms' parameter.
546pub async fn nodes_migrateall(configuration: &configuration::Configuration, node: &str, nodes_migrateall_request: models::NodesMigrateallRequest) -> Result<models::NodesMigrateallResponse, Error<NodesMigrateallError>> {
547    // add a prefix to parameters to efficiently prevent name collisions
548    let p_path_node = node;
549    let p_body_nodes_migrateall_request = nodes_migrateall_request;
550
551    let uri_str = format!("{}/nodes/{node}/migrateall", configuration.base_path, node=crate::apis::urlencode(p_path_node));
552    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
553
554    if let Some(ref user_agent) = configuration.user_agent {
555        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
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("Authorization", value);
564    };
565    if let Some(ref apikey) = configuration.api_key {
566        let key = apikey.key.clone();
567        let value = match apikey.prefix {
568            Some(ref prefix) => format!("{} {}", prefix, key),
569            None => key,
570        };
571        req_builder = req_builder.header("CSRFPreventionToken", value);
572    };
573    req_builder = req_builder.json(&p_body_nodes_migrateall_request);
574
575    let req = req_builder.build()?;
576    let resp = configuration.client.execute(req).await?;
577
578    let status = resp.status();
579    let content_type = resp
580        .headers()
581        .get("content-type")
582        .and_then(|v| v.to_str().ok())
583        .unwrap_or("application/octet-stream");
584    let content_type = super::ContentType::from(content_type);
585
586    if !status.is_client_error() && !status.is_server_error() {
587        let content = resp.text().await?;
588        match content_type {
589            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
590            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesMigrateallResponse`"))),
591            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::NodesMigrateallResponse`")))),
592        }
593    } else {
594        let content = resp.text().await?;
595        let entity: Option<NodesMigrateallError> = serde_json::from_str(&content).ok();
596        Err(Error::ResponseError(ResponseContent { status, content, entity }))
597    }
598}
599
600/// Read tap/vm network device interface counters
601pub async fn nodes_netstat(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesNetstatResponse, Error<NodesNetstatError>> {
602    // add a prefix to parameters to efficiently prevent name collisions
603    let p_path_node = node;
604
605    let uri_str = format!("{}/nodes/{node}/netstat", configuration.base_path, node=crate::apis::urlencode(p_path_node));
606    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
607
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::NodesNetstatResponse`"))),
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::NodesNetstatResponse`")))),
645        }
646    } else {
647        let content = resp.text().await?;
648        let entity: Option<NodesNetstatError> = serde_json::from_str(&content).ok();
649        Err(Error::ResponseError(ResponseContent { status, content, entity }))
650    }
651}
652
653/// List all tags for an OCI repository reference.
654pub async fn nodes_query_oci_repo_tags(configuration: &configuration::Configuration, node: &str, reference: &str) -> Result<models::NodesQueryOciRepoTagsResponse, Error<NodesQueryOciRepoTagsError>> {
655    // add a prefix to parameters to efficiently prevent name collisions
656    let p_path_node = node;
657    let p_query_reference = reference;
658
659    let uri_str = format!("{}/nodes/{node}/query-oci-repo-tags", configuration.base_path, node=crate::apis::urlencode(p_path_node));
660    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
661
662    req_builder = req_builder.query(&[("reference", &p_query_reference.to_string())]);
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
683    let req = req_builder.build()?;
684    let resp = configuration.client.execute(req).await?;
685
686    let status = resp.status();
687    let content_type = resp
688        .headers()
689        .get("content-type")
690        .and_then(|v| v.to_str().ok())
691        .unwrap_or("application/octet-stream");
692    let content_type = super::ContentType::from(content_type);
693
694    if !status.is_client_error() && !status.is_server_error() {
695        let content = resp.text().await?;
696        match content_type {
697            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
698            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesQueryOciRepoTagsResponse`"))),
699            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::NodesQueryOciRepoTagsResponse`")))),
700        }
701    } else {
702        let content = resp.text().await?;
703        let entity: Option<NodesQueryOciRepoTagsError> = serde_json::from_str(&content).ok();
704        Err(Error::ResponseError(ResponseContent { status, content, entity }))
705    }
706}
707
708/// Query metadata of an URL: file size, file name and mime type.
709pub async fn nodes_query_url_metadata(configuration: &configuration::Configuration, node: &str, url: &str, verify_certificates: Option<&str>) -> Result<models::NodesQueryUrlMetadataResponse, Error<NodesQueryUrlMetadataError>> {
710    // add a prefix to parameters to efficiently prevent name collisions
711    let p_path_node = node;
712    let p_query_url = url;
713    let p_query_verify_certificates = verify_certificates;
714
715    let uri_str = format!("{}/nodes/{node}/query-url-metadata", configuration.base_path, node=crate::apis::urlencode(p_path_node));
716    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
717
718    req_builder = req_builder.query(&[("url", &p_query_url.to_string())]);
719    if let Some(ref param_value) = p_query_verify_certificates {
720        req_builder = req_builder.query(&[("verify-certificates", &param_value.to_string())]);
721    }
722    if let Some(ref user_agent) = configuration.user_agent {
723        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
724    }
725    if let Some(ref apikey) = configuration.api_key {
726        let key = apikey.key.clone();
727        let value = match apikey.prefix {
728            Some(ref prefix) => format!("{} {}", prefix, key),
729            None => key,
730        };
731        req_builder = req_builder.header("Authorization", value);
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("CSRFPreventionToken", value);
740    };
741
742    let req = req_builder.build()?;
743    let resp = configuration.client.execute(req).await?;
744
745    let status = resp.status();
746    let content_type = resp
747        .headers()
748        .get("content-type")
749        .and_then(|v| v.to_str().ok())
750        .unwrap_or("application/octet-stream");
751    let content_type = super::ContentType::from(content_type);
752
753    if !status.is_client_error() && !status.is_server_error() {
754        let content = resp.text().await?;
755        match content_type {
756            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
757            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesQueryUrlMetadataResponse`"))),
758            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::NodesQueryUrlMetadataResponse`")))),
759        }
760    } else {
761        let content = resp.text().await?;
762        let entity: Option<NodesQueryUrlMetadataError> = serde_json::from_str(&content).ok();
763        Err(Error::ResponseError(ResponseContent { status, content, entity }))
764    }
765}
766
767/// Gather various systems information about a node
768pub async fn nodes_report(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesReportResponse, Error<NodesReportError>> {
769    // add a prefix to parameters to efficiently prevent name collisions
770    let p_path_node = node;
771
772    let uri_str = format!("{}/nodes/{node}/report", configuration.base_path, node=crate::apis::urlencode(p_path_node));
773    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
774
775    if let Some(ref user_agent) = configuration.user_agent {
776        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
777    }
778    if let Some(ref apikey) = configuration.api_key {
779        let key = apikey.key.clone();
780        let value = match apikey.prefix {
781            Some(ref prefix) => format!("{} {}", prefix, key),
782            None => key,
783        };
784        req_builder = req_builder.header("Authorization", value);
785    };
786    if let Some(ref apikey) = configuration.api_key {
787        let key = apikey.key.clone();
788        let value = match apikey.prefix {
789            Some(ref prefix) => format!("{} {}", prefix, key),
790            None => key,
791        };
792        req_builder = req_builder.header("CSRFPreventionToken", value);
793    };
794
795    let req = req_builder.build()?;
796    let resp = configuration.client.execute(req).await?;
797
798    let status = resp.status();
799    let content_type = resp
800        .headers()
801        .get("content-type")
802        .and_then(|v| v.to_str().ok())
803        .unwrap_or("application/octet-stream");
804    let content_type = super::ContentType::from(content_type);
805
806    if !status.is_client_error() && !status.is_server_error() {
807        let content = resp.text().await?;
808        match content_type {
809            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
810            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesReportResponse`"))),
811            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::NodesReportResponse`")))),
812        }
813    } else {
814        let content = resp.text().await?;
815        let entity: Option<NodesReportError> = serde_json::from_str(&content).ok();
816        Err(Error::ResponseError(ResponseContent { status, content, entity }))
817    }
818}
819
820/// Read node RRD statistics (returns PNG)
821pub async fn nodes_rrd(configuration: &configuration::Configuration, ds: &str, node: &str, timeframe: models::PveNodesTimeframeEnum, cf: Option<models::PveCfEnum>) -> Result<models::NodesRrdResponse, Error<NodesRrdError>> {
822    // add a prefix to parameters to efficiently prevent name collisions
823    let p_query_ds = ds;
824    let p_path_node = node;
825    let p_query_timeframe = timeframe;
826    let p_query_cf = cf;
827
828    let uri_str = format!("{}/nodes/{node}/rrd", configuration.base_path, node=crate::apis::urlencode(p_path_node));
829    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
830
831    if let Some(ref param_value) = p_query_cf {
832        req_builder = req_builder.query(&[("cf", &param_value.to_string())]);
833    }
834    req_builder = req_builder.query(&[("ds", &p_query_ds.to_string())]);
835    req_builder = req_builder.query(&[("timeframe", &p_query_timeframe.to_string())]);
836    if let Some(ref user_agent) = configuration.user_agent {
837        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
838    }
839    if let Some(ref apikey) = configuration.api_key {
840        let key = apikey.key.clone();
841        let value = match apikey.prefix {
842            Some(ref prefix) => format!("{} {}", prefix, key),
843            None => key,
844        };
845        req_builder = req_builder.header("Authorization", value);
846    };
847    if let Some(ref apikey) = configuration.api_key {
848        let key = apikey.key.clone();
849        let value = match apikey.prefix {
850            Some(ref prefix) => format!("{} {}", prefix, key),
851            None => key,
852        };
853        req_builder = req_builder.header("CSRFPreventionToken", value);
854    };
855
856    let req = req_builder.build()?;
857    let resp = configuration.client.execute(req).await?;
858
859    let status = resp.status();
860    let content_type = resp
861        .headers()
862        .get("content-type")
863        .and_then(|v| v.to_str().ok())
864        .unwrap_or("application/octet-stream");
865    let content_type = super::ContentType::from(content_type);
866
867    if !status.is_client_error() && !status.is_server_error() {
868        let content = resp.text().await?;
869        match content_type {
870            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
871            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesRrdResponse`"))),
872            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::NodesRrdResponse`")))),
873        }
874    } else {
875        let content = resp.text().await?;
876        let entity: Option<NodesRrdError> = serde_json::from_str(&content).ok();
877        Err(Error::ResponseError(ResponseContent { status, content, entity }))
878    }
879}
880
881/// Read node RRD statistics
882pub async fn nodes_rrddata(configuration: &configuration::Configuration, node: &str, timeframe: models::PveNodesTimeframeEnum, cf: Option<models::PveCfEnum>) -> Result<models::NodesRrddataResponse, Error<NodesRrddataError>> {
883    // add a prefix to parameters to efficiently prevent name collisions
884    let p_path_node = node;
885    let p_query_timeframe = timeframe;
886    let p_query_cf = cf;
887
888    let uri_str = format!("{}/nodes/{node}/rrddata", configuration.base_path, node=crate::apis::urlencode(p_path_node));
889    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
890
891    if let Some(ref param_value) = p_query_cf {
892        req_builder = req_builder.query(&[("cf", &param_value.to_string())]);
893    }
894    req_builder = req_builder.query(&[("timeframe", &p_query_timeframe.to_string())]);
895    if let Some(ref user_agent) = configuration.user_agent {
896        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
897    }
898    if let Some(ref apikey) = configuration.api_key {
899        let key = apikey.key.clone();
900        let value = match apikey.prefix {
901            Some(ref prefix) => format!("{} {}", prefix, key),
902            None => key,
903        };
904        req_builder = req_builder.header("Authorization", value);
905    };
906    if let Some(ref apikey) = configuration.api_key {
907        let key = apikey.key.clone();
908        let value = match apikey.prefix {
909            Some(ref prefix) => format!("{} {}", prefix, key),
910            None => key,
911        };
912        req_builder = req_builder.header("CSRFPreventionToken", value);
913    };
914
915    let req = req_builder.build()?;
916    let resp = configuration.client.execute(req).await?;
917
918    let status = resp.status();
919    let content_type = resp
920        .headers()
921        .get("content-type")
922        .and_then(|v| v.to_str().ok())
923        .unwrap_or("application/octet-stream");
924    let content_type = super::ContentType::from(content_type);
925
926    if !status.is_client_error() && !status.is_server_error() {
927        let content = resp.text().await?;
928        match content_type {
929            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
930            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesRrddataResponse`"))),
931            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::NodesRrddataResponse`")))),
932        }
933    } else {
934        let content = resp.text().await?;
935        let entity: Option<NodesRrddataError> = serde_json::from_str(&content).ok();
936        Err(Error::ResponseError(ResponseContent { status, content, entity }))
937    }
938}
939
940/// Creates a SPICE shell.
941pub async fn nodes_spiceshell(configuration: &configuration::Configuration, node: &str, nodes_spiceshell_request: Option<models::NodesSpiceshellRequest>) -> Result<models::NodesSpiceshellResponse, Error<NodesSpiceshellError>> {
942    // add a prefix to parameters to efficiently prevent name collisions
943    let p_path_node = node;
944    let p_body_nodes_spiceshell_request = nodes_spiceshell_request;
945
946    let uri_str = format!("{}/nodes/{node}/spiceshell", configuration.base_path, node=crate::apis::urlencode(p_path_node));
947    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
948
949    if let Some(ref user_agent) = configuration.user_agent {
950        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
951    }
952    if let Some(ref apikey) = configuration.api_key {
953        let key = apikey.key.clone();
954        let value = match apikey.prefix {
955            Some(ref prefix) => format!("{} {}", prefix, key),
956            None => key,
957        };
958        req_builder = req_builder.header("Authorization", value);
959    };
960    if let Some(ref apikey) = configuration.api_key {
961        let key = apikey.key.clone();
962        let value = match apikey.prefix {
963            Some(ref prefix) => format!("{} {}", prefix, key),
964            None => key,
965        };
966        req_builder = req_builder.header("CSRFPreventionToken", value);
967    };
968    req_builder = req_builder.json(&p_body_nodes_spiceshell_request);
969
970    let req = req_builder.build()?;
971    let resp = configuration.client.execute(req).await?;
972
973    let status = resp.status();
974    let content_type = resp
975        .headers()
976        .get("content-type")
977        .and_then(|v| v.to_str().ok())
978        .unwrap_or("application/octet-stream");
979    let content_type = super::ContentType::from(content_type);
980
981    if !status.is_client_error() && !status.is_server_error() {
982        let content = resp.text().await?;
983        match content_type {
984            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
985            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesSpiceshellResponse`"))),
986            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::NodesSpiceshellResponse`")))),
987        }
988    } else {
989        let content = resp.text().await?;
990        let entity: Option<NodesSpiceshellError> = serde_json::from_str(&content).ok();
991        Err(Error::ResponseError(ResponseContent { status, content, entity }))
992    }
993}
994
995/// Start all VMs and containers located on this node (by default only those with onboot=1).  Permissions: The 'VM.PowerMgmt' permission is required on '/' or on '/vms/<ID>' for each ID passed via the 'vms' parameter.
996pub async fn nodes_startall(configuration: &configuration::Configuration, node: &str, nodes_startall_request: Option<models::NodesStartallRequest>) -> Result<models::NodesStartallResponse, Error<NodesStartallError>> {
997    // add a prefix to parameters to efficiently prevent name collisions
998    let p_path_node = node;
999    let p_body_nodes_startall_request = nodes_startall_request;
1000
1001    let uri_str = format!("{}/nodes/{node}/startall", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1002    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1003
1004    if let Some(ref user_agent) = configuration.user_agent {
1005        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1006    }
1007    if let Some(ref apikey) = configuration.api_key {
1008        let key = apikey.key.clone();
1009        let value = match apikey.prefix {
1010            Some(ref prefix) => format!("{} {}", prefix, key),
1011            None => key,
1012        };
1013        req_builder = req_builder.header("Authorization", value);
1014    };
1015    if let Some(ref apikey) = configuration.api_key {
1016        let key = apikey.key.clone();
1017        let value = match apikey.prefix {
1018            Some(ref prefix) => format!("{} {}", prefix, key),
1019            None => key,
1020        };
1021        req_builder = req_builder.header("CSRFPreventionToken", value);
1022    };
1023    req_builder = req_builder.json(&p_body_nodes_startall_request);
1024
1025    let req = req_builder.build()?;
1026    let resp = configuration.client.execute(req).await?;
1027
1028    let status = resp.status();
1029    let content_type = resp
1030        .headers()
1031        .get("content-type")
1032        .and_then(|v| v.to_str().ok())
1033        .unwrap_or("application/octet-stream");
1034    let content_type = super::ContentType::from(content_type);
1035
1036    if !status.is_client_error() && !status.is_server_error() {
1037        let content = resp.text().await?;
1038        match content_type {
1039            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1040            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStartallResponse`"))),
1041            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::NodesStartallResponse`")))),
1042        }
1043    } else {
1044        let content = resp.text().await?;
1045        let entity: Option<NodesStartallError> = serde_json::from_str(&content).ok();
1046        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1047    }
1048}
1049
1050/// Stop all VMs and Containers.  Permissions: The 'VM.PowerMgmt' permission is required on '/' or on '/vms/<ID>' for each ID passed via the 'vms' parameter.
1051pub async fn nodes_stopall(configuration: &configuration::Configuration, node: &str, nodes_stopall_request: Option<models::NodesStopallRequest>) -> Result<models::NodesStopallResponse, Error<NodesStopallError>> {
1052    // add a prefix to parameters to efficiently prevent name collisions
1053    let p_path_node = node;
1054    let p_body_nodes_stopall_request = nodes_stopall_request;
1055
1056    let uri_str = format!("{}/nodes/{node}/stopall", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1057    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1058
1059    if let Some(ref user_agent) = configuration.user_agent {
1060        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1061    }
1062    if let Some(ref apikey) = configuration.api_key {
1063        let key = apikey.key.clone();
1064        let value = match apikey.prefix {
1065            Some(ref prefix) => format!("{} {}", prefix, key),
1066            None => key,
1067        };
1068        req_builder = req_builder.header("Authorization", value);
1069    };
1070    if let Some(ref apikey) = configuration.api_key {
1071        let key = apikey.key.clone();
1072        let value = match apikey.prefix {
1073            Some(ref prefix) => format!("{} {}", prefix, key),
1074            None => key,
1075        };
1076        req_builder = req_builder.header("CSRFPreventionToken", value);
1077    };
1078    req_builder = req_builder.json(&p_body_nodes_stopall_request);
1079
1080    let req = req_builder.build()?;
1081    let resp = configuration.client.execute(req).await?;
1082
1083    let status = resp.status();
1084    let content_type = resp
1085        .headers()
1086        .get("content-type")
1087        .and_then(|v| v.to_str().ok())
1088        .unwrap_or("application/octet-stream");
1089    let content_type = super::ContentType::from(content_type);
1090
1091    if !status.is_client_error() && !status.is_server_error() {
1092        let content = resp.text().await?;
1093        match content_type {
1094            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1095            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesStopallResponse`"))),
1096            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::NodesStopallResponse`")))),
1097        }
1098    } else {
1099        let content = resp.text().await?;
1100        let entity: Option<NodesStopallError> = serde_json::from_str(&content).ok();
1101        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1102    }
1103}
1104
1105/// Suspend all VMs.  Permissions: The 'VM.PowerMgmt' permission is required on '/' or on '/vms/<ID>' for each ID passed via the 'vms' parameter. Additionally, you need 'VM.Config.Disk' on the '/vms/{vmid}' path and 'Datastore.AllocateSpace' for the configured state-storage(s)
1106pub async fn nodes_suspendall(configuration: &configuration::Configuration, node: &str, nodes_suspendall_request: Option<models::NodesSuspendallRequest>) -> Result<models::NodesSuspendallResponse, Error<NodesSuspendallError>> {
1107    // add a prefix to parameters to efficiently prevent name collisions
1108    let p_path_node = node;
1109    let p_body_nodes_suspendall_request = nodes_suspendall_request;
1110
1111    let uri_str = format!("{}/nodes/{node}/suspendall", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1112    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1113
1114    if let Some(ref user_agent) = configuration.user_agent {
1115        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1116    }
1117    if let Some(ref apikey) = configuration.api_key {
1118        let key = apikey.key.clone();
1119        let value = match apikey.prefix {
1120            Some(ref prefix) => format!("{} {}", prefix, key),
1121            None => key,
1122        };
1123        req_builder = req_builder.header("Authorization", value);
1124    };
1125    if let Some(ref apikey) = configuration.api_key {
1126        let key = apikey.key.clone();
1127        let value = match apikey.prefix {
1128            Some(ref prefix) => format!("{} {}", prefix, key),
1129            None => key,
1130        };
1131        req_builder = req_builder.header("CSRFPreventionToken", value);
1132    };
1133    req_builder = req_builder.json(&p_body_nodes_suspendall_request);
1134
1135    let req = req_builder.build()?;
1136    let resp = configuration.client.execute(req).await?;
1137
1138    let status = resp.status();
1139    let content_type = resp
1140        .headers()
1141        .get("content-type")
1142        .and_then(|v| v.to_str().ok())
1143        .unwrap_or("application/octet-stream");
1144    let content_type = super::ContentType::from(content_type);
1145
1146    if !status.is_client_error() && !status.is_server_error() {
1147        let content = resp.text().await?;
1148        match content_type {
1149            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1150            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesSuspendallResponse`"))),
1151            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::NodesSuspendallResponse`")))),
1152        }
1153    } else {
1154        let content = resp.text().await?;
1155        let entity: Option<NodesSuspendallError> = serde_json::from_str(&content).ok();
1156        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1157    }
1158}
1159
1160/// Read system log
1161pub async fn nodes_syslog(configuration: &configuration::Configuration, node: &str, limit: Option<i64>, service: Option<&str>, since: Option<&str>, start: Option<i64>, until: Option<&str>) -> Result<models::NodesSyslogResponse, Error<NodesSyslogError>> {
1162    // add a prefix to parameters to efficiently prevent name collisions
1163    let p_path_node = node;
1164    let p_query_limit = limit;
1165    let p_query_service = service;
1166    let p_query_since = since;
1167    let p_query_start = start;
1168    let p_query_until = until;
1169
1170    let uri_str = format!("{}/nodes/{node}/syslog", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1171    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1172
1173    if let Some(ref param_value) = p_query_limit {
1174        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
1175    }
1176    if let Some(ref param_value) = p_query_service {
1177        req_builder = req_builder.query(&[("service", &param_value.to_string())]);
1178    }
1179    if let Some(ref param_value) = p_query_since {
1180        req_builder = req_builder.query(&[("since", &param_value.to_string())]);
1181    }
1182    if let Some(ref param_value) = p_query_start {
1183        req_builder = req_builder.query(&[("start", &param_value.to_string())]);
1184    }
1185    if let Some(ref param_value) = p_query_until {
1186        req_builder = req_builder.query(&[("until", &param_value.to_string())]);
1187    }
1188    if let Some(ref user_agent) = configuration.user_agent {
1189        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1190    }
1191    if let Some(ref apikey) = configuration.api_key {
1192        let key = apikey.key.clone();
1193        let value = match apikey.prefix {
1194            Some(ref prefix) => format!("{} {}", prefix, key),
1195            None => key,
1196        };
1197        req_builder = req_builder.header("Authorization", value);
1198    };
1199    if let Some(ref apikey) = configuration.api_key {
1200        let key = apikey.key.clone();
1201        let value = match apikey.prefix {
1202            Some(ref prefix) => format!("{} {}", prefix, key),
1203            None => key,
1204        };
1205        req_builder = req_builder.header("CSRFPreventionToken", value);
1206    };
1207
1208    let req = req_builder.build()?;
1209    let resp = configuration.client.execute(req).await?;
1210
1211    let status = resp.status();
1212    let content_type = resp
1213        .headers()
1214        .get("content-type")
1215        .and_then(|v| v.to_str().ok())
1216        .unwrap_or("application/octet-stream");
1217    let content_type = super::ContentType::from(content_type);
1218
1219    if !status.is_client_error() && !status.is_server_error() {
1220        let content = resp.text().await?;
1221        match content_type {
1222            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1223            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesSyslogResponse`"))),
1224            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::NodesSyslogResponse`")))),
1225        }
1226    } else {
1227        let content = resp.text().await?;
1228        let entity: Option<NodesSyslogError> = serde_json::from_str(&content).ok();
1229        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1230    }
1231}
1232
1233/// Creates a VNC Shell proxy.
1234pub async fn nodes_termproxy(configuration: &configuration::Configuration, node: &str, nodes_termproxy_request: Option<models::NodesTermproxyRequest>) -> Result<models::NodesTermproxyResponse, Error<NodesTermproxyError>> {
1235    // add a prefix to parameters to efficiently prevent name collisions
1236    let p_path_node = node;
1237    let p_body_nodes_termproxy_request = nodes_termproxy_request;
1238
1239    let uri_str = format!("{}/nodes/{node}/termproxy", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1240    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1241
1242    if let Some(ref user_agent) = configuration.user_agent {
1243        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1244    }
1245    if let Some(ref apikey) = configuration.api_key {
1246        let key = apikey.key.clone();
1247        let value = match apikey.prefix {
1248            Some(ref prefix) => format!("{} {}", prefix, key),
1249            None => key,
1250        };
1251        req_builder = req_builder.header("Authorization", value);
1252    };
1253    if let Some(ref apikey) = configuration.api_key {
1254        let key = apikey.key.clone();
1255        let value = match apikey.prefix {
1256            Some(ref prefix) => format!("{} {}", prefix, key),
1257            None => key,
1258        };
1259        req_builder = req_builder.header("CSRFPreventionToken", value);
1260    };
1261    req_builder = req_builder.json(&p_body_nodes_termproxy_request);
1262
1263    let req = req_builder.build()?;
1264    let resp = configuration.client.execute(req).await?;
1265
1266    let status = resp.status();
1267    let content_type = resp
1268        .headers()
1269        .get("content-type")
1270        .and_then(|v| v.to_str().ok())
1271        .unwrap_or("application/octet-stream");
1272    let content_type = super::ContentType::from(content_type);
1273
1274    if !status.is_client_error() && !status.is_server_error() {
1275        let content = resp.text().await?;
1276        match content_type {
1277            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1278            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesTermproxyResponse`"))),
1279            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::NodesTermproxyResponse`")))),
1280        }
1281    } else {
1282        let content = resp.text().await?;
1283        let entity: Option<NodesTermproxyError> = serde_json::from_str(&content).ok();
1284        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1285    }
1286}
1287
1288/// API version details
1289pub async fn nodes_version(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesVersionResponse, Error<NodesVersionError>> {
1290    // add a prefix to parameters to efficiently prevent name collisions
1291    let p_path_node = node;
1292
1293    let uri_str = format!("{}/nodes/{node}/version", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1294    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1295
1296    if let Some(ref user_agent) = configuration.user_agent {
1297        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1298    }
1299    if let Some(ref apikey) = configuration.api_key {
1300        let key = apikey.key.clone();
1301        let value = match apikey.prefix {
1302            Some(ref prefix) => format!("{} {}", prefix, key),
1303            None => key,
1304        };
1305        req_builder = req_builder.header("Authorization", value);
1306    };
1307    if let Some(ref apikey) = configuration.api_key {
1308        let key = apikey.key.clone();
1309        let value = match apikey.prefix {
1310            Some(ref prefix) => format!("{} {}", prefix, key),
1311            None => key,
1312        };
1313        req_builder = req_builder.header("CSRFPreventionToken", value);
1314    };
1315
1316    let req = req_builder.build()?;
1317    let resp = configuration.client.execute(req).await?;
1318
1319    let status = resp.status();
1320    let content_type = resp
1321        .headers()
1322        .get("content-type")
1323        .and_then(|v| v.to_str().ok())
1324        .unwrap_or("application/octet-stream");
1325    let content_type = super::ContentType::from(content_type);
1326
1327    if !status.is_client_error() && !status.is_server_error() {
1328        let content = resp.text().await?;
1329        match content_type {
1330            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1331            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesVersionResponse`"))),
1332            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::NodesVersionResponse`")))),
1333        }
1334    } else {
1335        let content = resp.text().await?;
1336        let entity: Option<NodesVersionError> = serde_json::from_str(&content).ok();
1337        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1338    }
1339}
1340
1341/// Creates a VNC Shell proxy.
1342pub async fn nodes_vncshell(configuration: &configuration::Configuration, node: &str, nodes_vncshell_request: Option<models::NodesVncshellRequest>) -> Result<models::NodesVncshellResponse, Error<NodesVncshellError>> {
1343    // add a prefix to parameters to efficiently prevent name collisions
1344    let p_path_node = node;
1345    let p_body_nodes_vncshell_request = nodes_vncshell_request;
1346
1347    let uri_str = format!("{}/nodes/{node}/vncshell", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1348    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1349
1350    if let Some(ref user_agent) = configuration.user_agent {
1351        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1352    }
1353    if let Some(ref apikey) = configuration.api_key {
1354        let key = apikey.key.clone();
1355        let value = match apikey.prefix {
1356            Some(ref prefix) => format!("{} {}", prefix, key),
1357            None => key,
1358        };
1359        req_builder = req_builder.header("Authorization", value);
1360    };
1361    if let Some(ref apikey) = configuration.api_key {
1362        let key = apikey.key.clone();
1363        let value = match apikey.prefix {
1364            Some(ref prefix) => format!("{} {}", prefix, key),
1365            None => key,
1366        };
1367        req_builder = req_builder.header("CSRFPreventionToken", value);
1368    };
1369    req_builder = req_builder.json(&p_body_nodes_vncshell_request);
1370
1371    let req = req_builder.build()?;
1372    let resp = configuration.client.execute(req).await?;
1373
1374    let status = resp.status();
1375    let content_type = resp
1376        .headers()
1377        .get("content-type")
1378        .and_then(|v| v.to_str().ok())
1379        .unwrap_or("application/octet-stream");
1380    let content_type = super::ContentType::from(content_type);
1381
1382    if !status.is_client_error() && !status.is_server_error() {
1383        let content = resp.text().await?;
1384        match content_type {
1385            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1386            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesVncshellResponse`"))),
1387            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::NodesVncshellResponse`")))),
1388        }
1389    } else {
1390        let content = resp.text().await?;
1391        let entity: Option<NodesVncshellError> = serde_json::from_str(&content).ok();
1392        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1393    }
1394}
1395
1396/// Opens a websocket for VNC traffic.  Permissions: You also need to pass a valid ticket (vncticket).  Wire-level note: this endpoint answers HTTP 101 Upgrade, not a JSON body. The 200 schema below is the apidoc-declared shape for tooling, but real clients perform a WebSocket upgrade and exchange framed messages on the resulting socket. See the `x-pve-websocket` extension for the framing and the list of sibling endpoints that issue tickets.
1397pub async fn nodes_vncwebsocket(configuration: &configuration::Configuration, node: &str, port: i32, vncticket: &str) -> Result<models::NodesVncwebsocketResponse, Error<NodesVncwebsocketError>> {
1398    // add a prefix to parameters to efficiently prevent name collisions
1399    let p_path_node = node;
1400    let p_query_port = port;
1401    let p_query_vncticket = vncticket;
1402
1403    let uri_str = format!("{}/nodes/{node}/vncwebsocket", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1404    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1405
1406    req_builder = req_builder.query(&[("port", &p_query_port.to_string())]);
1407    req_builder = req_builder.query(&[("vncticket", &p_query_vncticket.to_string())]);
1408    if let Some(ref user_agent) = configuration.user_agent {
1409        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1410    }
1411    if let Some(ref apikey) = configuration.api_key {
1412        let key = apikey.key.clone();
1413        let value = match apikey.prefix {
1414            Some(ref prefix) => format!("{} {}", prefix, key),
1415            None => key,
1416        };
1417        req_builder = req_builder.header("Authorization", value);
1418    };
1419    if let Some(ref apikey) = configuration.api_key {
1420        let key = apikey.key.clone();
1421        let value = match apikey.prefix {
1422            Some(ref prefix) => format!("{} {}", prefix, key),
1423            None => key,
1424        };
1425        req_builder = req_builder.header("CSRFPreventionToken", value);
1426    };
1427
1428    let req = req_builder.build()?;
1429    let resp = configuration.client.execute(req).await?;
1430
1431    let status = resp.status();
1432    let content_type = resp
1433        .headers()
1434        .get("content-type")
1435        .and_then(|v| v.to_str().ok())
1436        .unwrap_or("application/octet-stream");
1437    let content_type = super::ContentType::from(content_type);
1438
1439    if !status.is_client_error() && !status.is_server_error() {
1440        let content = resp.text().await?;
1441        match content_type {
1442            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1443            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesVncwebsocketResponse`"))),
1444            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::NodesVncwebsocketResponse`")))),
1445        }
1446    } else {
1447        let content = resp.text().await?;
1448        let entity: Option<NodesVncwebsocketError> = serde_json::from_str(&content).ok();
1449        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1450    }
1451}
1452
1453/// Try to wake a node via 'wake on LAN' network packet.
1454pub async fn nodes_wakeonlan(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesWakeonlanResponse, Error<NodesWakeonlanError>> {
1455    // add a prefix to parameters to efficiently prevent name collisions
1456    let p_path_node = node;
1457
1458    let uri_str = format!("{}/nodes/{node}/wakeonlan", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1459    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1460
1461    if let Some(ref user_agent) = configuration.user_agent {
1462        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1463    }
1464    if let Some(ref apikey) = configuration.api_key {
1465        let key = apikey.key.clone();
1466        let value = match apikey.prefix {
1467            Some(ref prefix) => format!("{} {}", prefix, key),
1468            None => key,
1469        };
1470        req_builder = req_builder.header("Authorization", value);
1471    };
1472    if let Some(ref apikey) = configuration.api_key {
1473        let key = apikey.key.clone();
1474        let value = match apikey.prefix {
1475            Some(ref prefix) => format!("{} {}", prefix, key),
1476            None => key,
1477        };
1478        req_builder = req_builder.header("CSRFPreventionToken", value);
1479    };
1480
1481    let req = req_builder.build()?;
1482    let resp = configuration.client.execute(req).await?;
1483
1484    let status = resp.status();
1485    let content_type = resp
1486        .headers()
1487        .get("content-type")
1488        .and_then(|v| v.to_str().ok())
1489        .unwrap_or("application/octet-stream");
1490    let content_type = super::ContentType::from(content_type);
1491
1492    if !status.is_client_error() && !status.is_server_error() {
1493        let content = resp.text().await?;
1494        match content_type {
1495            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1496            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesWakeonlanResponse`"))),
1497            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::NodesWakeonlanResponse`")))),
1498        }
1499    } else {
1500        let content = resp.text().await?;
1501        let entity: Option<NodesWakeonlanError> = serde_json::from_str(&content).ok();
1502        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1503    }
1504}
1505
clientapi_pve/apis/nodes_api.rs

clientapi_pve/apis/
nodes_api.rs
