Skip to main content

clientapi_pve/models/
cluster_config_addnode_request.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
11use crate::models;
12use serde::{Deserialize, Serialize};
13
14#[derive(Clone, Default, Debug, PartialEq)]
15pub struct ClusterConfigAddnodeRequest {
16
17
18    /// The JOIN_API_VERSION of the new node.
19    pub apiversion: Option<i64>,
20
21    /// Do not throw error if node already exists.
22    pub force: Option<models::PveBoolean>,
23
24    /// IP Address of node to add. Used as fallback if no links are given.
25    pub new_node_ip: Option<String>,
26
27    /// Node id for this node.
28    pub nodeid: Option<i64>,
29
30    /// Number of votes for this node
31    pub votes: Option<i64>,
32
33    /// Links family. Wire form: `link0..link7`. Serialised by the manual impls below.
34    pub links: Option<std::collections::HashMap<u32, models::PveLinkField>>,
35}
36
37impl ClusterConfigAddnodeRequest {
38    pub fn new() -> ClusterConfigAddnodeRequest {
39        ClusterConfigAddnodeRequest {
40            
41            apiversion: None,
42            
43            force: None,
44            
45            new_node_ip: None,
46            
47            nodeid: None,
48            
49            votes: None,
50            
51            links: None,
52        }
53    }
54}
55
56
57// Flattens indexed-family maps to/from `<base><idx>` wire keys.
58impl serde::Serialize for ClusterConfigAddnodeRequest {
59    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
60        use serde::ser::Error;
61        let mut map = serde_json::Map::new();
62        
63        {
64            let _v = serde_json::to_value(&self.apiversion).map_err(Error::custom)?;
65            if !_v.is_null() {
66                map.insert("apiversion".to_string(), _v);
67            }
68        }
69        
70        {
71            let _v = serde_json::to_value(&self.force).map_err(Error::custom)?;
72            if !_v.is_null() {
73                map.insert("force".to_string(), _v);
74            }
75        }
76        
77        {
78            let _v = serde_json::to_value(&self.new_node_ip).map_err(Error::custom)?;
79            if !_v.is_null() {
80                map.insert("new_node_ip".to_string(), _v);
81            }
82        }
83        
84        {
85            let _v = serde_json::to_value(&self.nodeid).map_err(Error::custom)?;
86            if !_v.is_null() {
87                map.insert("nodeid".to_string(), _v);
88            }
89        }
90        
91        {
92            let _v = serde_json::to_value(&self.votes).map_err(Error::custom)?;
93            if !_v.is_null() {
94                map.insert("votes".to_string(), _v);
95            }
96        }
97        
98        if let Some(ref _m) = self.links {
99            for (_idx, _val) in _m.iter() {
100                map.insert(format!("link{}", _idx), serde_json::to_value(_val).map_err(Error::custom)?);
101            }
102        }
103        serde_json::Value::Object(map).serialize(serializer)
104    }
105}
106
107impl<'de> serde::Deserialize<'de> for ClusterConfigAddnodeRequest {
108    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
109        use serde::de::Error;
110        let mut raw: serde_json::Map<String, serde_json::Value> =
111            serde::Deserialize::deserialize(deserializer)?;
112        let mut __links: std::collections::HashMap<u32, models::PveLinkField> = std::collections::HashMap::new();
113        {
114            let _prefix = "link";
115            let _keys: Vec<String> = raw.keys()
116                .filter(|k| {
117                    if let Some(_suffix) = k.strip_prefix(_prefix) {
118                        !_suffix.is_empty() && _suffix.chars().all(|c| c.is_ascii_digit())
119                    } else {
120                        false
121                    }
122                })
123                .cloned()
124                .collect();
125            for _key in _keys {
126                let _suffix = _key.strip_prefix(_prefix).unwrap();
127                let _idx: u32 = _suffix.parse().map_err(Error::custom)?;
128                let _value = raw.remove(&_key).unwrap();
129                let _item: models::PveLinkField = serde_json::from_value(_value).map_err(Error::custom)?;
130                __links.insert(_idx, _item);
131            }
132        }
133        Ok(ClusterConfigAddnodeRequest {
134            
135            apiversion: serde_json::from_value(raw.remove("apiversion").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
136            
137            force: serde_json::from_value(raw.remove("force").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
138            
139            new_node_ip: serde_json::from_value(raw.remove("new_node_ip").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
140            
141            nodeid: serde_json::from_value(raw.remove("nodeid").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
142            
143            votes: serde_json::from_value(raw.remove("votes").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
144            
145            links: if __links.is_empty() { None } else { Some(__links) },
146        })
147    }
148}
149
150