clientapi_pve/apis/
nodes_tasks_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_tasks_node_tasks`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum NodesTasksNodeTasksError {
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_tasks_read_task_log`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum NodesTasksReadTaskLogError {
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_tasks_read_task_status`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum NodesTasksReadTaskStatusError {
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_tasks_stop_task`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum NodesTasksStopTaskError {
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_tasks_upid_index`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum NodesTasksUpidIndexError {
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
89/// Read task list for one node (finished tasks).  Permissions: List task associated with the current user, or all task the user has 'Sys.Audit' permissions on /nodes/<node> (the <node> the task runs on).
90pub async fn nodes_tasks_node_tasks(configuration: &configuration::Configuration, node: &str, errors: Option<&str>, limit: Option<i64>, since: Option<i64>, source: Option<&str>, start: Option<i64>, statusfilter: Option<&str>, typefilter: Option<&str>, until: Option<i64>, userfilter: Option<&str>, vmid: Option<i32>) -> Result<models::NodesTasksNodeTasksResponse, Error<NodesTasksNodeTasksError>> {
91    // add a prefix to parameters to efficiently prevent name collisions
92    let p_path_node = node;
93    let p_query_errors = errors;
94    let p_query_limit = limit;
95    let p_query_since = since;
96    let p_query_source = source;
97    let p_query_start = start;
98    let p_query_statusfilter = statusfilter;
99    let p_query_typefilter = typefilter;
100    let p_query_until = until;
101    let p_query_userfilter = userfilter;
102    let p_query_vmid = vmid;
103
104    let uri_str = format!("{}/nodes/{node}/tasks", configuration.base_path, node=crate::apis::urlencode(p_path_node));
105    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
106
107    if let Some(ref param_value) = p_query_errors {
108        req_builder = req_builder.query(&[("errors", &param_value.to_string())]);
109    }
110    if let Some(ref param_value) = p_query_limit {
111        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
112    }
113    if let Some(ref param_value) = p_query_since {
114        req_builder = req_builder.query(&[("since", &param_value.to_string())]);
115    }
116    if let Some(ref param_value) = p_query_source {
117        req_builder = req_builder.query(&[("source", &param_value.to_string())]);
118    }
119    if let Some(ref param_value) = p_query_start {
120        req_builder = req_builder.query(&[("start", &param_value.to_string())]);
121    }
122    if let Some(ref param_value) = p_query_statusfilter {
123        req_builder = req_builder.query(&[("statusfilter", &param_value.to_string())]);
124    }
125    if let Some(ref param_value) = p_query_typefilter {
126        req_builder = req_builder.query(&[("typefilter", &param_value.to_string())]);
127    }
128    if let Some(ref param_value) = p_query_until {
129        req_builder = req_builder.query(&[("until", &param_value.to_string())]);
130    }
131    if let Some(ref param_value) = p_query_userfilter {
132        req_builder = req_builder.query(&[("userfilter", &param_value.to_string())]);
133    }
134    if let Some(ref param_value) = p_query_vmid {
135        req_builder = req_builder.query(&[("vmid", &param_value.to_string())]);
136    }
137    if let Some(ref user_agent) = configuration.user_agent {
138        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
139    }
140    if let Some(ref apikey) = configuration.api_key {
141        let key = apikey.key.clone();
142        let value = match apikey.prefix {
143            Some(ref prefix) => format!("{} {}", prefix, key),
144            None => key,
145        };
146        req_builder = req_builder.header("Authorization", value);
147    };
148    if let Some(ref apikey) = configuration.api_key {
149        let key = apikey.key.clone();
150        let value = match apikey.prefix {
151            Some(ref prefix) => format!("{} {}", prefix, key),
152            None => key,
153        };
154        req_builder = req_builder.header("CSRFPreventionToken", value);
155    };
156
157    let req = req_builder.build()?;
158    let resp = configuration.client.execute(req).await?;
159
160    let status = resp.status();
161    let content_type = resp
162        .headers()
163        .get("content-type")
164        .and_then(|v| v.to_str().ok())
165        .unwrap_or("application/octet-stream");
166    let content_type = super::ContentType::from(content_type);
167
168    if !status.is_client_error() && !status.is_server_error() {
169        let content = resp.text().await?;
170        match content_type {
171            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
172            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesTasksNodeTasksResponse`"))),
173            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::NodesTasksNodeTasksResponse`")))),
174        }
175    } else {
176        let content = resp.text().await?;
177        let entity: Option<NodesTasksNodeTasksError> = serde_json::from_str(&content).ok();
178        Err(Error::ResponseError(ResponseContent { status, content, entity }))
179    }
180}
181
182/// Read task log.  Permissions: The user needs 'Sys.Audit' permissions on '/nodes/<node>' if they aren't the owner of the task.
183pub async fn nodes_tasks_read_task_log(configuration: &configuration::Configuration, node: &str, upid: &str, download: Option<&str>, limit: Option<i64>, start: Option<i64>) -> Result<models::NodesTasksReadTaskLogResponse, Error<NodesTasksReadTaskLogError>> {
184    // add a prefix to parameters to efficiently prevent name collisions
185    let p_path_node = node;
186    let p_path_upid = upid;
187    let p_query_download = download;
188    let p_query_limit = limit;
189    let p_query_start = start;
190
191    let uri_str = format!("{}/nodes/{node}/tasks/{upid}/log", configuration.base_path, node=crate::apis::urlencode(p_path_node), upid=crate::apis::urlencode(p_path_upid));
192    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
193
194    if let Some(ref param_value) = p_query_download {
195        req_builder = req_builder.query(&[("download", &param_value.to_string())]);
196    }
197    if let Some(ref param_value) = p_query_limit {
198        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
199    }
200    if let Some(ref param_value) = p_query_start {
201        req_builder = req_builder.query(&[("start", &param_value.to_string())]);
202    }
203    if let Some(ref user_agent) = configuration.user_agent {
204        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
205    }
206    if let Some(ref apikey) = configuration.api_key {
207        let key = apikey.key.clone();
208        let value = match apikey.prefix {
209            Some(ref prefix) => format!("{} {}", prefix, key),
210            None => key,
211        };
212        req_builder = req_builder.header("Authorization", value);
213    };
214    if let Some(ref apikey) = configuration.api_key {
215        let key = apikey.key.clone();
216        let value = match apikey.prefix {
217            Some(ref prefix) => format!("{} {}", prefix, key),
218            None => key,
219        };
220        req_builder = req_builder.header("CSRFPreventionToken", value);
221    };
222
223    let req = req_builder.build()?;
224    let resp = configuration.client.execute(req).await?;
225
226    let status = resp.status();
227    let content_type = resp
228        .headers()
229        .get("content-type")
230        .and_then(|v| v.to_str().ok())
231        .unwrap_or("application/octet-stream");
232    let content_type = super::ContentType::from(content_type);
233
234    if !status.is_client_error() && !status.is_server_error() {
235        let content = resp.text().await?;
236        match content_type {
237            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
238            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesTasksReadTaskLogResponse`"))),
239            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::NodesTasksReadTaskLogResponse`")))),
240        }
241    } else {
242        let content = resp.text().await?;
243        let entity: Option<NodesTasksReadTaskLogError> = serde_json::from_str(&content).ok();
244        Err(Error::ResponseError(ResponseContent { status, content, entity }))
245    }
246}
247
248/// Read task status.  Permissions: The user needs 'Sys.Audit' permissions on '/nodes/<node>' if they are not the owner of the task.
249pub async fn nodes_tasks_read_task_status(configuration: &configuration::Configuration, node: &str, upid: &str) -> Result<models::NodesTasksReadTaskStatusResponse, Error<NodesTasksReadTaskStatusError>> {
250    // add a prefix to parameters to efficiently prevent name collisions
251    let p_path_node = node;
252    let p_path_upid = upid;
253
254    let uri_str = format!("{}/nodes/{node}/tasks/{upid}/status", configuration.base_path, node=crate::apis::urlencode(p_path_node), upid=crate::apis::urlencode(p_path_upid));
255    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
256
257    if let Some(ref user_agent) = configuration.user_agent {
258        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
259    }
260    if let Some(ref apikey) = configuration.api_key {
261        let key = apikey.key.clone();
262        let value = match apikey.prefix {
263            Some(ref prefix) => format!("{} {}", prefix, key),
264            None => key,
265        };
266        req_builder = req_builder.header("Authorization", value);
267    };
268    if let Some(ref apikey) = configuration.api_key {
269        let key = apikey.key.clone();
270        let value = match apikey.prefix {
271            Some(ref prefix) => format!("{} {}", prefix, key),
272            None => key,
273        };
274        req_builder = req_builder.header("CSRFPreventionToken", value);
275    };
276
277    let req = req_builder.build()?;
278    let resp = configuration.client.execute(req).await?;
279
280    let status = resp.status();
281    let content_type = resp
282        .headers()
283        .get("content-type")
284        .and_then(|v| v.to_str().ok())
285        .unwrap_or("application/octet-stream");
286    let content_type = super::ContentType::from(content_type);
287
288    if !status.is_client_error() && !status.is_server_error() {
289        let content = resp.text().await?;
290        match content_type {
291            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
292            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesTasksReadTaskStatusResponse`"))),
293            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::NodesTasksReadTaskStatusResponse`")))),
294        }
295    } else {
296        let content = resp.text().await?;
297        let entity: Option<NodesTasksReadTaskStatusError> = serde_json::from_str(&content).ok();
298        Err(Error::ResponseError(ResponseContent { status, content, entity }))
299    }
300}
301
302/// Stop a task.  Permissions: The user needs 'Sys.Modify' permissions on '/nodes/<node>' if they aren't the owner of the task.
303pub async fn nodes_tasks_stop_task(configuration: &configuration::Configuration, node: &str, upid: &str) -> Result<models::NodesTasksStopTaskResponse, Error<NodesTasksStopTaskError>> {
304    // add a prefix to parameters to efficiently prevent name collisions
305    let p_path_node = node;
306    let p_path_upid = upid;
307
308    let uri_str = format!("{}/nodes/{node}/tasks/{upid}", configuration.base_path, node=crate::apis::urlencode(p_path_node), upid=crate::apis::urlencode(p_path_upid));
309    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
310
311    if let Some(ref user_agent) = configuration.user_agent {
312        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
313    }
314    if let Some(ref apikey) = configuration.api_key {
315        let key = apikey.key.clone();
316        let value = match apikey.prefix {
317            Some(ref prefix) => format!("{} {}", prefix, key),
318            None => key,
319        };
320        req_builder = req_builder.header("Authorization", value);
321    };
322    if let Some(ref apikey) = configuration.api_key {
323        let key = apikey.key.clone();
324        let value = match apikey.prefix {
325            Some(ref prefix) => format!("{} {}", prefix, key),
326            None => key,
327        };
328        req_builder = req_builder.header("CSRFPreventionToken", value);
329    };
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::NodesTasksStopTaskResponse`"))),
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::NodesTasksStopTaskResponse`")))),
348        }
349    } else {
350        let content = resp.text().await?;
351        let entity: Option<NodesTasksStopTaskError> = serde_json::from_str(&content).ok();
352        Err(Error::ResponseError(ResponseContent { status, content, entity }))
353    }
354}
355
356/// 
357pub async fn nodes_tasks_upid_index(configuration: &configuration::Configuration, node: &str, upid: &str) -> Result<models::NodesTasksUpidIndexResponse, Error<NodesTasksUpidIndexError>> {
358    // add a prefix to parameters to efficiently prevent name collisions
359    let p_path_node = node;
360    let p_path_upid = upid;
361
362    let uri_str = format!("{}/nodes/{node}/tasks/{upid}", configuration.base_path, node=crate::apis::urlencode(p_path_node), upid=crate::apis::urlencode(p_path_upid));
363    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
364
365    if let Some(ref user_agent) = configuration.user_agent {
366        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
367    }
368    if let Some(ref apikey) = configuration.api_key {
369        let key = apikey.key.clone();
370        let value = match apikey.prefix {
371            Some(ref prefix) => format!("{} {}", prefix, key),
372            None => key,
373        };
374        req_builder = req_builder.header("Authorization", value);
375    };
376    if let Some(ref apikey) = configuration.api_key {
377        let key = apikey.key.clone();
378        let value = match apikey.prefix {
379            Some(ref prefix) => format!("{} {}", prefix, key),
380            None => key,
381        };
382        req_builder = req_builder.header("CSRFPreventionToken", value);
383    };
384
385    let req = req_builder.build()?;
386    let resp = configuration.client.execute(req).await?;
387
388    let status = resp.status();
389    let content_type = resp
390        .headers()
391        .get("content-type")
392        .and_then(|v| v.to_str().ok())
393        .unwrap_or("application/octet-stream");
394    let content_type = super::ContentType::from(content_type);
395
396    if !status.is_client_error() && !status.is_server_error() {
397        let content = resp.text().await?;
398        match content_type {
399            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
400            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesTasksUpidIndexResponse`"))),
401            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::NodesTasksUpidIndexResponse`")))),
402        }
403    } else {
404        let content = resp.text().await?;
405        let entity: Option<NodesTasksUpidIndexError> = serde_json::from_str(&content).ok();
406        Err(Error::ResponseError(ResponseContent { status, content, entity }))
407    }
408}
409
clientapi_pve/apis/nodes_tasks_api.rs

clientapi_pve/apis/
nodes_tasks_api.rs
