clientapi_pve/apis/
nodes_firewall_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_firewall_create_rule`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum NodesFirewallCreateRuleError {
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_firewall_delete_rule`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum NodesFirewallDeleteRuleError {
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_firewall_get_firewall`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum NodesFirewallGetFirewallError {
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_firewall_get_options`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum NodesFirewallGetOptionsError {
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_firewall_get_rule`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum NodesFirewallGetRuleError {
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_firewall_get_rules`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum NodesFirewallGetRulesError {
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_firewall_log`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum NodesFirewallLogError {
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_firewall_set_options`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum NodesFirewallSetOptionsError {
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_firewall_update_rule`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum NodesFirewallUpdateRuleError {
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
145/// Create new rule.
146pub async fn nodes_firewall_create_rule(configuration: &configuration::Configuration, node: &str, cluster_firewall_create_rule_request: models::ClusterFirewallCreateRuleRequest) -> Result<models::NodesFirewallCreateRuleResponse, Error<NodesFirewallCreateRuleError>> {
147    // add a prefix to parameters to efficiently prevent name collisions
148    let p_path_node = node;
149    let p_body_cluster_firewall_create_rule_request = cluster_firewall_create_rule_request;
150
151    let uri_str = format!("{}/nodes/{node}/firewall/rules", configuration.base_path, node=crate::apis::urlencode(p_path_node));
152    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
153
154    if let Some(ref user_agent) = configuration.user_agent {
155        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
156    }
157    if let Some(ref apikey) = configuration.api_key {
158        let key = apikey.key.clone();
159        let value = match apikey.prefix {
160            Some(ref prefix) => format!("{} {}", prefix, key),
161            None => key,
162        };
163        req_builder = req_builder.header("Authorization", value);
164    };
165    if let Some(ref apikey) = configuration.api_key {
166        let key = apikey.key.clone();
167        let value = match apikey.prefix {
168            Some(ref prefix) => format!("{} {}", prefix, key),
169            None => key,
170        };
171        req_builder = req_builder.header("CSRFPreventionToken", value);
172    };
173    req_builder = req_builder.json(&p_body_cluster_firewall_create_rule_request);
174
175    let req = req_builder.build()?;
176    let resp = configuration.client.execute(req).await?;
177
178    let status = resp.status();
179    let content_type = resp
180        .headers()
181        .get("content-type")
182        .and_then(|v| v.to_str().ok())
183        .unwrap_or("application/octet-stream");
184    let content_type = super::ContentType::from(content_type);
185
186    if !status.is_client_error() && !status.is_server_error() {
187        let content = resp.text().await?;
188        match content_type {
189            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
190            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallCreateRuleResponse`"))),
191            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::NodesFirewallCreateRuleResponse`")))),
192        }
193    } else {
194        let content = resp.text().await?;
195        let entity: Option<NodesFirewallCreateRuleError> = serde_json::from_str(&content).ok();
196        Err(Error::ResponseError(ResponseContent { status, content, entity }))
197    }
198}
199
200/// Delete rule.
201pub async fn nodes_firewall_delete_rule(configuration: &configuration::Configuration, node: &str, pos: i64, digest: Option<&str>) -> Result<models::NodesFirewallDeleteRuleResponse, Error<NodesFirewallDeleteRuleError>> {
202    // add a prefix to parameters to efficiently prevent name collisions
203    let p_path_node = node;
204    let p_path_pos = pos;
205    let p_query_digest = digest;
206
207    let uri_str = format!("{}/nodes/{node}/firewall/rules/{pos}", configuration.base_path, node=crate::apis::urlencode(p_path_node), pos=p_path_pos);
208    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
209
210    if let Some(ref param_value) = p_query_digest {
211        req_builder = req_builder.query(&[("digest", &param_value.to_string())]);
212    }
213    if let Some(ref user_agent) = configuration.user_agent {
214        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
215    }
216    if let Some(ref apikey) = configuration.api_key {
217        let key = apikey.key.clone();
218        let value = match apikey.prefix {
219            Some(ref prefix) => format!("{} {}", prefix, key),
220            None => key,
221        };
222        req_builder = req_builder.header("Authorization", value);
223    };
224    if let Some(ref apikey) = configuration.api_key {
225        let key = apikey.key.clone();
226        let value = match apikey.prefix {
227            Some(ref prefix) => format!("{} {}", prefix, key),
228            None => key,
229        };
230        req_builder = req_builder.header("CSRFPreventionToken", value);
231    };
232
233    let req = req_builder.build()?;
234    let resp = configuration.client.execute(req).await?;
235
236    let status = resp.status();
237    let content_type = resp
238        .headers()
239        .get("content-type")
240        .and_then(|v| v.to_str().ok())
241        .unwrap_or("application/octet-stream");
242    let content_type = super::ContentType::from(content_type);
243
244    if !status.is_client_error() && !status.is_server_error() {
245        let content = resp.text().await?;
246        match content_type {
247            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
248            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallDeleteRuleResponse`"))),
249            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::NodesFirewallDeleteRuleResponse`")))),
250        }
251    } else {
252        let content = resp.text().await?;
253        let entity: Option<NodesFirewallDeleteRuleError> = serde_json::from_str(&content).ok();
254        Err(Error::ResponseError(ResponseContent { status, content, entity }))
255    }
256}
257
258/// Directory index.
259pub async fn nodes_firewall_get_firewall(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesFirewallGetFirewallResponse, Error<NodesFirewallGetFirewallError>> {
260    // add a prefix to parameters to efficiently prevent name collisions
261    let p_path_node = node;
262
263    let uri_str = format!("{}/nodes/{node}/firewall", configuration.base_path, node=crate::apis::urlencode(p_path_node));
264    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
265
266    if let Some(ref user_agent) = configuration.user_agent {
267        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
268    }
269    if let Some(ref apikey) = configuration.api_key {
270        let key = apikey.key.clone();
271        let value = match apikey.prefix {
272            Some(ref prefix) => format!("{} {}", prefix, key),
273            None => key,
274        };
275        req_builder = req_builder.header("Authorization", value);
276    };
277    if let Some(ref apikey) = configuration.api_key {
278        let key = apikey.key.clone();
279        let value = match apikey.prefix {
280            Some(ref prefix) => format!("{} {}", prefix, key),
281            None => key,
282        };
283        req_builder = req_builder.header("CSRFPreventionToken", value);
284    };
285
286    let req = req_builder.build()?;
287    let resp = configuration.client.execute(req).await?;
288
289    let status = resp.status();
290    let content_type = resp
291        .headers()
292        .get("content-type")
293        .and_then(|v| v.to_str().ok())
294        .unwrap_or("application/octet-stream");
295    let content_type = super::ContentType::from(content_type);
296
297    if !status.is_client_error() && !status.is_server_error() {
298        let content = resp.text().await?;
299        match content_type {
300            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
301            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallGetFirewallResponse`"))),
302            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::NodesFirewallGetFirewallResponse`")))),
303        }
304    } else {
305        let content = resp.text().await?;
306        let entity: Option<NodesFirewallGetFirewallError> = serde_json::from_str(&content).ok();
307        Err(Error::ResponseError(ResponseContent { status, content, entity }))
308    }
309}
310
311/// Get host firewall options.
312pub async fn nodes_firewall_get_options(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesFirewallGetOptionsResponse, Error<NodesFirewallGetOptionsError>> {
313    // add a prefix to parameters to efficiently prevent name collisions
314    let p_path_node = node;
315
316    let uri_str = format!("{}/nodes/{node}/firewall/options", configuration.base_path, node=crate::apis::urlencode(p_path_node));
317    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
318
319    if let Some(ref user_agent) = configuration.user_agent {
320        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
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("Authorization", value);
329    };
330    if let Some(ref apikey) = configuration.api_key {
331        let key = apikey.key.clone();
332        let value = match apikey.prefix {
333            Some(ref prefix) => format!("{} {}", prefix, key),
334            None => key,
335        };
336        req_builder = req_builder.header("CSRFPreventionToken", value);
337    };
338
339    let req = req_builder.build()?;
340    let resp = configuration.client.execute(req).await?;
341
342    let status = resp.status();
343    let content_type = resp
344        .headers()
345        .get("content-type")
346        .and_then(|v| v.to_str().ok())
347        .unwrap_or("application/octet-stream");
348    let content_type = super::ContentType::from(content_type);
349
350    if !status.is_client_error() && !status.is_server_error() {
351        let content = resp.text().await?;
352        match content_type {
353            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
354            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallGetOptionsResponse`"))),
355            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::NodesFirewallGetOptionsResponse`")))),
356        }
357    } else {
358        let content = resp.text().await?;
359        let entity: Option<NodesFirewallGetOptionsError> = serde_json::from_str(&content).ok();
360        Err(Error::ResponseError(ResponseContent { status, content, entity }))
361    }
362}
363
364/// Get single rule data.
365pub async fn nodes_firewall_get_rule(configuration: &configuration::Configuration, node: &str, pos: i64) -> Result<models::NodesFirewallGetRuleResponse, Error<NodesFirewallGetRuleError>> {
366    // add a prefix to parameters to efficiently prevent name collisions
367    let p_path_node = node;
368    let p_path_pos = pos;
369
370    let uri_str = format!("{}/nodes/{node}/firewall/rules/{pos}", configuration.base_path, node=crate::apis::urlencode(p_path_node), pos=p_path_pos);
371    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
372
373    if let Some(ref user_agent) = configuration.user_agent {
374        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
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("Authorization", value);
383    };
384    if let Some(ref apikey) = configuration.api_key {
385        let key = apikey.key.clone();
386        let value = match apikey.prefix {
387            Some(ref prefix) => format!("{} {}", prefix, key),
388            None => key,
389        };
390        req_builder = req_builder.header("CSRFPreventionToken", value);
391    };
392
393    let req = req_builder.build()?;
394    let resp = configuration.client.execute(req).await?;
395
396    let status = resp.status();
397    let content_type = resp
398        .headers()
399        .get("content-type")
400        .and_then(|v| v.to_str().ok())
401        .unwrap_or("application/octet-stream");
402    let content_type = super::ContentType::from(content_type);
403
404    if !status.is_client_error() && !status.is_server_error() {
405        let content = resp.text().await?;
406        match content_type {
407            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
408            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallGetRuleResponse`"))),
409            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesFirewallGetRuleResponse`")))),
410        }
411    } else {
412        let content = resp.text().await?;
413        let entity: Option<NodesFirewallGetRuleError> = serde_json::from_str(&content).ok();
414        Err(Error::ResponseError(ResponseContent { status, content, entity }))
415    }
416}
417
418/// List rules.
419pub async fn nodes_firewall_get_rules(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesFirewallGetRulesResponse, Error<NodesFirewallGetRulesError>> {
420    // add a prefix to parameters to efficiently prevent name collisions
421    let p_path_node = node;
422
423    let uri_str = format!("{}/nodes/{node}/firewall/rules", configuration.base_path, node=crate::apis::urlencode(p_path_node));
424    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
425
426    if let Some(ref user_agent) = configuration.user_agent {
427        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
428    }
429    if let Some(ref apikey) = configuration.api_key {
430        let key = apikey.key.clone();
431        let value = match apikey.prefix {
432            Some(ref prefix) => format!("{} {}", prefix, key),
433            None => key,
434        };
435        req_builder = req_builder.header("Authorization", value);
436    };
437    if let Some(ref apikey) = configuration.api_key {
438        let key = apikey.key.clone();
439        let value = match apikey.prefix {
440            Some(ref prefix) => format!("{} {}", prefix, key),
441            None => key,
442        };
443        req_builder = req_builder.header("CSRFPreventionToken", value);
444    };
445
446    let req = req_builder.build()?;
447    let resp = configuration.client.execute(req).await?;
448
449    let status = resp.status();
450    let content_type = resp
451        .headers()
452        .get("content-type")
453        .and_then(|v| v.to_str().ok())
454        .unwrap_or("application/octet-stream");
455    let content_type = super::ContentType::from(content_type);
456
457    if !status.is_client_error() && !status.is_server_error() {
458        let content = resp.text().await?;
459        match content_type {
460            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
461            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallGetRulesResponse`"))),
462            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesFirewallGetRulesResponse`")))),
463        }
464    } else {
465        let content = resp.text().await?;
466        let entity: Option<NodesFirewallGetRulesError> = serde_json::from_str(&content).ok();
467        Err(Error::ResponseError(ResponseContent { status, content, entity }))
468    }
469}
470
471/// Read firewall log
472pub async fn nodes_firewall_log(configuration: &configuration::Configuration, node: &str, limit: Option<i64>, since: Option<i64>, start: Option<i64>, until: Option<i64>) -> Result<models::NodesFirewallLogResponse, Error<NodesFirewallLogError>> {
473    // add a prefix to parameters to efficiently prevent name collisions
474    let p_path_node = node;
475    let p_query_limit = limit;
476    let p_query_since = since;
477    let p_query_start = start;
478    let p_query_until = until;
479
480    let uri_str = format!("{}/nodes/{node}/firewall/log", configuration.base_path, node=crate::apis::urlencode(p_path_node));
481    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
482
483    if let Some(ref param_value) = p_query_limit {
484        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
485    }
486    if let Some(ref param_value) = p_query_since {
487        req_builder = req_builder.query(&[("since", &param_value.to_string())]);
488    }
489    if let Some(ref param_value) = p_query_start {
490        req_builder = req_builder.query(&[("start", &param_value.to_string())]);
491    }
492    if let Some(ref param_value) = p_query_until {
493        req_builder = req_builder.query(&[("until", &param_value.to_string())]);
494    }
495    if let Some(ref user_agent) = configuration.user_agent {
496        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
497    }
498    if let Some(ref apikey) = configuration.api_key {
499        let key = apikey.key.clone();
500        let value = match apikey.prefix {
501            Some(ref prefix) => format!("{} {}", prefix, key),
502            None => key,
503        };
504        req_builder = req_builder.header("Authorization", value);
505    };
506    if let Some(ref apikey) = configuration.api_key {
507        let key = apikey.key.clone();
508        let value = match apikey.prefix {
509            Some(ref prefix) => format!("{} {}", prefix, key),
510            None => key,
511        };
512        req_builder = req_builder.header("CSRFPreventionToken", value);
513    };
514
515    let req = req_builder.build()?;
516    let resp = configuration.client.execute(req).await?;
517
518    let status = resp.status();
519    let content_type = resp
520        .headers()
521        .get("content-type")
522        .and_then(|v| v.to_str().ok())
523        .unwrap_or("application/octet-stream");
524    let content_type = super::ContentType::from(content_type);
525
526    if !status.is_client_error() && !status.is_server_error() {
527        let content = resp.text().await?;
528        match content_type {
529            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
530            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallLogResponse`"))),
531            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::NodesFirewallLogResponse`")))),
532        }
533    } else {
534        let content = resp.text().await?;
535        let entity: Option<NodesFirewallLogError> = serde_json::from_str(&content).ok();
536        Err(Error::ResponseError(ResponseContent { status, content, entity }))
537    }
538}
539
540/// Set Firewall options.
541pub async fn nodes_firewall_set_options(configuration: &configuration::Configuration, node: &str, nodes_firewall_set_options_request: Option<models::NodesFirewallSetOptionsRequest>) -> Result<models::NodesFirewallSetOptionsResponse, Error<NodesFirewallSetOptionsError>> {
542    // add a prefix to parameters to efficiently prevent name collisions
543    let p_path_node = node;
544    let p_body_nodes_firewall_set_options_request = nodes_firewall_set_options_request;
545
546    let uri_str = format!("{}/nodes/{node}/firewall/options", configuration.base_path, node=crate::apis::urlencode(p_path_node));
547    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
548
549    if let Some(ref user_agent) = configuration.user_agent {
550        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
551    }
552    if let Some(ref apikey) = configuration.api_key {
553        let key = apikey.key.clone();
554        let value = match apikey.prefix {
555            Some(ref prefix) => format!("{} {}", prefix, key),
556            None => key,
557        };
558        req_builder = req_builder.header("Authorization", value);
559    };
560    if let Some(ref apikey) = configuration.api_key {
561        let key = apikey.key.clone();
562        let value = match apikey.prefix {
563            Some(ref prefix) => format!("{} {}", prefix, key),
564            None => key,
565        };
566        req_builder = req_builder.header("CSRFPreventionToken", value);
567    };
568    req_builder = req_builder.json(&p_body_nodes_firewall_set_options_request);
569
570    let req = req_builder.build()?;
571    let resp = configuration.client.execute(req).await?;
572
573    let status = resp.status();
574    let content_type = resp
575        .headers()
576        .get("content-type")
577        .and_then(|v| v.to_str().ok())
578        .unwrap_or("application/octet-stream");
579    let content_type = super::ContentType::from(content_type);
580
581    if !status.is_client_error() && !status.is_server_error() {
582        let content = resp.text().await?;
583        match content_type {
584            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
585            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallSetOptionsResponse`"))),
586            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::NodesFirewallSetOptionsResponse`")))),
587        }
588    } else {
589        let content = resp.text().await?;
590        let entity: Option<NodesFirewallSetOptionsError> = serde_json::from_str(&content).ok();
591        Err(Error::ResponseError(ResponseContent { status, content, entity }))
592    }
593}
594
595/// Modify rule data.
596pub async fn nodes_firewall_update_rule(configuration: &configuration::Configuration, node: &str, pos: i64, cluster_firewall_update_rule_request: Option<models::ClusterFirewallUpdateRuleRequest>) -> Result<models::NodesFirewallUpdateRuleResponse, Error<NodesFirewallUpdateRuleError>> {
597    // add a prefix to parameters to efficiently prevent name collisions
598    let p_path_node = node;
599    let p_path_pos = pos;
600    let p_body_cluster_firewall_update_rule_request = cluster_firewall_update_rule_request;
601
602    let uri_str = format!("{}/nodes/{node}/firewall/rules/{pos}", configuration.base_path, node=crate::apis::urlencode(p_path_node), pos=p_path_pos);
603    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
604
605    if let Some(ref user_agent) = configuration.user_agent {
606        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
607    }
608    if let Some(ref apikey) = configuration.api_key {
609        let key = apikey.key.clone();
610        let value = match apikey.prefix {
611            Some(ref prefix) => format!("{} {}", prefix, key),
612            None => key,
613        };
614        req_builder = req_builder.header("Authorization", value);
615    };
616    if let Some(ref apikey) = configuration.api_key {
617        let key = apikey.key.clone();
618        let value = match apikey.prefix {
619            Some(ref prefix) => format!("{} {}", prefix, key),
620            None => key,
621        };
622        req_builder = req_builder.header("CSRFPreventionToken", value);
623    };
624    req_builder = req_builder.json(&p_body_cluster_firewall_update_rule_request);
625
626    let req = req_builder.build()?;
627    let resp = configuration.client.execute(req).await?;
628
629    let status = resp.status();
630    let content_type = resp
631        .headers()
632        .get("content-type")
633        .and_then(|v| v.to_str().ok())
634        .unwrap_or("application/octet-stream");
635    let content_type = super::ContentType::from(content_type);
636
637    if !status.is_client_error() && !status.is_server_error() {
638        let content = resp.text().await?;
639        match content_type {
640            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
641            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesFirewallUpdateRuleResponse`"))),
642            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::NodesFirewallUpdateRuleResponse`")))),
643        }
644    } else {
645        let content = resp.text().await?;
646        let entity: Option<NodesFirewallUpdateRuleError> = serde_json::from_str(&content).ok();
647        Err(Error::ResponseError(ResponseContent { status, content, entity }))
648    }
649}
650
clientapi_pve/apis/nodes_firewall_api.rs

clientapi_pve/apis/
nodes_firewall_api.rs
