1#[derive(Debug, Clone)]
2pub struct ResourcesClient<T> {
3 client: T,
4 path: String,
5}
6impl<T> ResourcesClient<T>
7where
8 T: crate::client::Client,
9{
10 pub fn new(client: T, parent_path: &str) -> Self {
11 Self {
12 client,
13 path: format!("{}{}", parent_path, "/resources"),
14 }
15 }
16}
17impl<T> ResourcesClient<T>
18where
19 T: crate::client::Client,
20{
21 #[doc = "Resources index (cluster wide)."]
22 #[doc = ""]
23 pub async fn get(&self, params: GetParams) -> Result<Vec<GetOutputItems>, T::Error> {
24 let path = self.path.to_string();
25 let optional_vec: Option<Vec<GetOutputItems>> = self.client.get(&path, ¶ms).await?;
26 Ok(optional_vec.unwrap_or_default())
27 }
28}
29impl GetOutputItems {
30 pub fn new(id: String, ty: Type2) -> Self {
31 Self {
32 id,
33 ty,
34 cgroup_mode: ::std::default::Default::default(),
35 content: ::std::default::Default::default(),
36 cpu: ::std::default::Default::default(),
37 disk: ::std::default::Default::default(),
38 diskread: ::std::default::Default::default(),
39 diskwrite: ::std::default::Default::default(),
40 hastate: ::std::default::Default::default(),
41 level: ::std::default::Default::default(),
42 lock: ::std::default::Default::default(),
43 maxcpu: ::std::default::Default::default(),
44 maxdisk: ::std::default::Default::default(),
45 maxmem: ::std::default::Default::default(),
46 mem: ::std::default::Default::default(),
47 memhost: ::std::default::Default::default(),
48 name: ::std::default::Default::default(),
49 netin: ::std::default::Default::default(),
50 netout: ::std::default::Default::default(),
51 network: ::std::default::Default::default(),
52 network_type: ::std::default::Default::default(),
53 node: ::std::default::Default::default(),
54 plugintype: ::std::default::Default::default(),
55 pool: ::std::default::Default::default(),
56 protocol: ::std::default::Default::default(),
57 sdn: ::std::default::Default::default(),
58 status: ::std::default::Default::default(),
59 storage: ::std::default::Default::default(),
60 tags: ::std::default::Default::default(),
61 template: ::std::default::Default::default(),
62 uptime: ::std::default::Default::default(),
63 vmid: ::std::default::Default::default(),
64 zone_type: ::std::default::Default::default(),
65 additional_properties: ::std::default::Default::default(),
66 }
67 }
68}
69#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
70pub struct GetOutputItems {
71 #[serde(rename = "cgroup-mode")]
72 #[serde(
73 serialize_with = "crate::types::serialize_int_optional",
74 deserialize_with = "crate::types::deserialize_int_optional"
75 )]
76 #[serde(skip_serializing_if = "Option::is_none", default)]
77 #[doc = "The cgroup mode the node operates under (for type 'node')."]
78 #[doc = ""]
79 pub cgroup_mode: Option<i64>,
80 #[serde(skip_serializing_if = "Option::is_none", default)]
81 #[doc = "Allowed storage content types (for type 'storage')."]
82 #[doc = ""]
83 pub content: Option<String>,
84 #[serde(skip_serializing_if = "Option::is_none", default)]
85 #[doc = "CPU utilization (for types 'node', 'qemu' and 'lxc')."]
86 #[doc = ""]
87 pub cpu: Option<CpuNum>,
88 #[serde(
89 serialize_with = "crate::types::serialize_unsigned_int_optional",
90 deserialize_with = "crate::types::deserialize_unsigned_int_optional"
91 )]
92 #[serde(skip_serializing_if = "Option::is_none", default)]
93 #[doc = "Used disk space in bytes (for type 'storage'), used root image space for VMs (for types 'qemu' and 'lxc')."]
94 #[doc = ""]
95 pub disk: Option<u64>,
96 #[serde(
97 serialize_with = "crate::types::serialize_int_optional",
98 deserialize_with = "crate::types::deserialize_int_optional"
99 )]
100 #[serde(skip_serializing_if = "Option::is_none", default)]
101 #[doc = "The number of bytes the guest read from its block devices since the guest was started. This info is not available for all storage types. (for types 'qemu' and 'lxc')"]
102 #[doc = ""]
103 pub diskread: Option<i64>,
104 #[serde(
105 serialize_with = "crate::types::serialize_int_optional",
106 deserialize_with = "crate::types::deserialize_int_optional"
107 )]
108 #[serde(skip_serializing_if = "Option::is_none", default)]
109 #[doc = "The number of bytes the guest wrote to its block devices since the guest was started. This info is not available for all storage types. (for types 'qemu' and 'lxc')"]
110 #[doc = ""]
111 pub diskwrite: Option<i64>,
112 #[serde(skip_serializing_if = "Option::is_none", default)]
113 #[doc = "HA service status (for HA managed VMs)."]
114 #[doc = ""]
115 pub hastate: Option<String>,
116 #[doc = "Resource id."]
117 #[doc = ""]
118 pub id: String,
119 #[serde(skip_serializing_if = "Option::is_none", default)]
120 #[doc = "Support level (for type 'node')."]
121 #[doc = ""]
122 pub level: Option<String>,
123 #[serde(skip_serializing_if = "Option::is_none", default)]
124 #[doc = "The guest's current config lock (for types 'qemu' and 'lxc')"]
125 #[doc = ""]
126 pub lock: Option<String>,
127 #[serde(skip_serializing_if = "Option::is_none", default)]
128 #[doc = "Number of available CPUs (for types 'node', 'qemu' and 'lxc')."]
129 #[doc = ""]
130 pub maxcpu: Option<MaxcpuNum>,
131 #[serde(
132 serialize_with = "crate::types::serialize_unsigned_int_optional",
133 deserialize_with = "crate::types::deserialize_unsigned_int_optional"
134 )]
135 #[serde(skip_serializing_if = "Option::is_none", default)]
136 #[doc = "Storage size in bytes (for type 'storage'), root image size for VMs (for types 'qemu' and 'lxc')."]
137 #[doc = ""]
138 pub maxdisk: Option<u64>,
139 #[serde(
140 serialize_with = "crate::types::serialize_int_optional",
141 deserialize_with = "crate::types::deserialize_int_optional"
142 )]
143 #[serde(skip_serializing_if = "Option::is_none", default)]
144 #[doc = "Number of available memory in bytes (for types 'node', 'qemu' and 'lxc')."]
145 #[doc = ""]
146 pub maxmem: Option<i64>,
147 #[serde(
148 serialize_with = "crate::types::serialize_unsigned_int_optional",
149 deserialize_with = "crate::types::deserialize_unsigned_int_optional"
150 )]
151 #[serde(skip_serializing_if = "Option::is_none", default)]
152 #[doc = "Used memory in bytes (for types 'node', 'qemu' and 'lxc')."]
153 #[doc = ""]
154 pub mem: Option<u64>,
155 #[serde(
156 serialize_with = "crate::types::serialize_unsigned_int_optional",
157 deserialize_with = "crate::types::deserialize_unsigned_int_optional"
158 )]
159 #[serde(skip_serializing_if = "Option::is_none", default)]
160 #[doc = "Used memory in bytes from the point of view of the host (for types 'qemu')."]
161 #[doc = ""]
162 pub memhost: Option<u64>,
163 #[serde(skip_serializing_if = "Option::is_none", default)]
164 #[doc = "Name of the resource."]
165 #[doc = ""]
166 pub name: Option<String>,
167 #[serde(
168 serialize_with = "crate::types::serialize_int_optional",
169 deserialize_with = "crate::types::deserialize_int_optional"
170 )]
171 #[serde(skip_serializing_if = "Option::is_none", default)]
172 #[doc = "The amount of traffic in bytes that was sent to the guest over the network since it was started. (for types 'qemu' and 'lxc')"]
173 #[doc = ""]
174 pub netin: Option<i64>,
175 #[serde(
176 serialize_with = "crate::types::serialize_int_optional",
177 deserialize_with = "crate::types::deserialize_int_optional"
178 )]
179 #[serde(skip_serializing_if = "Option::is_none", default)]
180 #[doc = "The amount of traffic in bytes that was sent from the guest over the network since it was started. (for types 'qemu' and 'lxc')"]
181 #[doc = ""]
182 pub netout: Option<i64>,
183 #[serde(skip_serializing_if = "Option::is_none", default)]
184 #[doc = "The name of a Network entity (for type 'network')."]
185 #[doc = ""]
186 pub network: Option<String>,
187 #[serde(rename = "network-type")]
188 #[serde(skip_serializing_if = "Option::is_none", default)]
189 #[doc = "The type of network resource (for type 'network')."]
190 #[doc = ""]
191 pub network_type: Option<NetworkType>,
192 #[serde(skip_serializing_if = "Option::is_none", default)]
193 #[doc = "The cluster node name (for types 'node', 'storage', 'qemu', and 'lxc')."]
194 #[doc = ""]
195 pub node: Option<String>,
196 #[serde(skip_serializing_if = "Option::is_none", default)]
197 #[doc = "More specific type, if available."]
198 #[doc = ""]
199 pub plugintype: Option<String>,
200 #[serde(skip_serializing_if = "Option::is_none", default)]
201 #[doc = "The pool name (for types 'pool', 'qemu' and 'lxc')."]
202 #[doc = ""]
203 pub pool: Option<String>,
204 #[serde(skip_serializing_if = "Option::is_none", default)]
205 #[doc = "The protocol of a fabric (for type 'network', network-type 'fabric')."]
206 #[doc = ""]
207 pub protocol: Option<String>,
208 #[serde(skip_serializing_if = "Option::is_none", default)]
209 #[doc = "The name of an SDN entity (for type 'sdn')"]
210 #[doc = ""]
211 pub sdn: Option<String>,
212 #[serde(skip_serializing_if = "Option::is_none", default)]
213 #[doc = "Resource type dependent status."]
214 #[doc = ""]
215 pub status: Option<String>,
216 #[serde(skip_serializing_if = "Option::is_none", default)]
217 #[doc = "The storage identifier (for type 'storage')."]
218 #[doc = ""]
219 pub storage: Option<String>,
220 #[serde(skip_serializing_if = "Option::is_none", default)]
221 #[doc = "The guest's tags (for types 'qemu' and 'lxc')"]
222 #[doc = ""]
223 pub tags: Option<String>,
224 #[serde(
225 serialize_with = "crate::types::serialize_bool_optional",
226 deserialize_with = "crate::types::deserialize_bool_optional"
227 )]
228 #[serde(skip_serializing_if = "Option::is_none", default)]
229 #[doc = "Determines if the guest is a template. (for types 'qemu' and 'lxc')"]
230 #[doc = ""]
231 pub template: Option<bool>,
232 #[serde(rename = "type")]
233 #[doc = "Resource type."]
234 #[doc = ""]
235 pub ty: Type2,
236 #[serde(
237 serialize_with = "crate::types::serialize_int_optional",
238 deserialize_with = "crate::types::deserialize_int_optional"
239 )]
240 #[serde(skip_serializing_if = "Option::is_none", default)]
241 #[doc = "Uptime of node or virtual guest in seconds (for types 'node', 'qemu' and 'lxc')."]
242 #[doc = ""]
243 pub uptime: Option<i64>,
244 #[serde(skip_serializing_if = "Option::is_none", default)]
245 #[doc = "The numerical vmid (for types 'qemu' and 'lxc')."]
246 #[doc = ""]
247 pub vmid: Option<VmidInt>,
248 #[serde(rename = "zone-type")]
249 #[serde(skip_serializing_if = "Option::is_none", default)]
250 #[doc = "The type of an SDN zone (for type 'sdn')."]
251 #[doc = ""]
252 pub zone_type: Option<String>,
253 #[serde(
254 flatten,
255 default,
256 skip_serializing_if = "::std::collections::HashMap::is_empty"
257 )]
258 pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
259}
260#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, Default)]
261pub struct GetParams {
262 #[serde(rename = "type")]
263 #[serde(skip_serializing_if = "Option::is_none", default)]
264 #[doc = "Resource type."]
265 #[doc = ""]
266 pub ty: Option<Type>,
267 #[serde(
268 flatten,
269 default,
270 skip_serializing_if = "::std::collections::HashMap::is_empty"
271 )]
272 pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
273}
274#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
275#[doc = "The type of network resource (for type 'network')."]
276#[doc = ""]
277pub enum NetworkType {
278 #[serde(rename = "fabric")]
279 Fabric,
280 #[serde(rename = "zone")]
281 Zone,
282}
283impl TryFrom<&str> for NetworkType {
284 type Error = String;
285 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
286 match value {
287 "fabric" => Ok(Self::Fabric),
288 "zone" => Ok(Self::Zone),
289 v => Err(format!("Unknown variant {v}")),
290 }
291 }
292}
293#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
294#[doc = "Resource type."]
295#[doc = ""]
296pub enum Type {
297 #[serde(rename = "node")]
298 Node,
299 #[serde(rename = "sdn")]
300 Sdn,
301 #[serde(rename = "storage")]
302 Storage,
303 #[serde(rename = "vm")]
304 Vm,
305}
306impl TryFrom<&str> for Type {
307 type Error = String;
308 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
309 match value {
310 "node" => Ok(Self::Node),
311 "sdn" => Ok(Self::Sdn),
312 "storage" => Ok(Self::Storage),
313 "vm" => Ok(Self::Vm),
314 v => Err(format!("Unknown variant {v}")),
315 }
316 }
317}
318#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
319#[doc = "Resource type."]
320#[doc = ""]
321pub enum Type2 {
322 #[serde(rename = "lxc")]
323 Lxc,
324 #[serde(rename = "network")]
325 Network,
326 #[serde(rename = "node")]
327 Node,
328 #[serde(rename = "openvz")]
329 Openvz,
330 #[serde(rename = "pool")]
331 Pool,
332 #[serde(rename = "qemu")]
333 Qemu,
334 #[serde(rename = "sdn")]
335 Sdn,
336 #[serde(rename = "storage")]
337 Storage,
338}
339impl TryFrom<&str> for Type2 {
340 type Error = String;
341 fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
342 match value {
343 "lxc" => Ok(Self::Lxc),
344 "network" => Ok(Self::Network),
345 "node" => Ok(Self::Node),
346 "openvz" => Ok(Self::Openvz),
347 "pool" => Ok(Self::Pool),
348 "qemu" => Ok(Self::Qemu),
349 "sdn" => Ok(Self::Sdn),
350 "storage" => Ok(Self::Storage),
351 v => Err(format!("Unknown variant {v}")),
352 }
353 }
354}
355#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
356pub struct VmidInt(i128);
357impl crate::types::bounded_integer::BoundedInteger for VmidInt {
358 const MIN: Option<i128> = Some(100i128);
359 const MAX: Option<i128> = Some(999999999i128);
360 const DEFAULT: Option<i128> = None::<i128>;
361 const TYPE_DESCRIPTION: &'static str = "an integer between 100 and 999999999";
362 fn get(&self) -> i128 {
363 self.0
364 }
365 fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
366 Self::validate(value)?;
367 Ok(Self(value))
368 }
369}
370impl std::convert::TryFrom<i128> for VmidInt {
371 type Error = crate::types::bounded_integer::BoundedIntegerError;
372 fn try_from(value: i128) -> Result<Self, Self::Error> {
373 crate::types::bounded_integer::BoundedInteger::new(value)
374 }
375}
376impl ::serde::Serialize for VmidInt {
377 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
378 where
379 S: ::serde::Serializer,
380 {
381 crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
382 }
383}
384impl<'de> ::serde::Deserialize<'de> for VmidInt {
385 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
386 where
387 D: ::serde::Deserializer<'de>,
388 {
389 crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
390 }
391}
392#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
393pub struct CpuNum(f64);
394impl crate::types::bounded_number::BoundedNumber for CpuNum {
395 const MIN: Option<f64> = Some(0f64);
396 const MAX: Option<f64> = None::<f64>;
397 const DEFAULT: Option<f64> = None::<f64>;
398 const TYPE_DESCRIPTION: &'static str = "an number greater than or equal to 0";
399 fn get(&self) -> f64 {
400 self.0
401 }
402 fn new(value: f64) -> Result<Self, crate::types::bounded_number::BoundedNumberError> {
403 Self::validate(value)?;
404 Ok(Self(value))
405 }
406}
407impl std::convert::TryFrom<f64> for CpuNum {
408 type Error = crate::types::bounded_number::BoundedNumberError;
409 fn try_from(value: f64) -> Result<Self, Self::Error> {
410 crate::types::bounded_number::BoundedNumber::new(value)
411 }
412}
413impl std::convert::TryFrom<f32> for CpuNum {
414 type Error = crate::types::bounded_number::BoundedNumberError;
415 fn try_from(value: f32) -> Result<Self, Self::Error> {
416 crate::types::bounded_number::BoundedNumber::new(value as f64)
417 }
418}
419impl std::convert::TryFrom<i32> for CpuNum {
420 type Error = crate::types::bounded_number::BoundedNumberError;
421 fn try_from(value: i32) -> Result<Self, Self::Error> {
422 crate::types::bounded_number::BoundedNumber::new(value as f64)
423 }
424}
425impl std::convert::TryFrom<i64> for CpuNum {
426 type Error = crate::types::bounded_number::BoundedNumberError;
427 fn try_from(value: i64) -> Result<Self, Self::Error> {
428 crate::types::bounded_number::BoundedNumber::new(value as f64)
429 }
430}
431impl ::serde::Serialize for CpuNum {
432 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
433 where
434 S: ::serde::Serializer,
435 {
436 crate::types::bounded_number::serialize_bounded_number(self, serializer)
437 }
438}
439impl<'de> ::serde::Deserialize<'de> for CpuNum {
440 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
441 where
442 D: ::serde::Deserializer<'de>,
443 {
444 crate::types::bounded_number::deserialize_bounded_number(deserializer)
445 }
446}
447#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
448pub struct MaxcpuNum(f64);
449impl crate::types::bounded_number::BoundedNumber for MaxcpuNum {
450 const MIN: Option<f64> = Some(0f64);
451 const MAX: Option<f64> = None::<f64>;
452 const DEFAULT: Option<f64> = None::<f64>;
453 const TYPE_DESCRIPTION: &'static str = "an number greater than or equal to 0";
454 fn get(&self) -> f64 {
455 self.0
456 }
457 fn new(value: f64) -> Result<Self, crate::types::bounded_number::BoundedNumberError> {
458 Self::validate(value)?;
459 Ok(Self(value))
460 }
461}
462impl std::convert::TryFrom<f64> for MaxcpuNum {
463 type Error = crate::types::bounded_number::BoundedNumberError;
464 fn try_from(value: f64) -> Result<Self, Self::Error> {
465 crate::types::bounded_number::BoundedNumber::new(value)
466 }
467}
468impl std::convert::TryFrom<f32> for MaxcpuNum {
469 type Error = crate::types::bounded_number::BoundedNumberError;
470 fn try_from(value: f32) -> Result<Self, Self::Error> {
471 crate::types::bounded_number::BoundedNumber::new(value as f64)
472 }
473}
474impl std::convert::TryFrom<i32> for MaxcpuNum {
475 type Error = crate::types::bounded_number::BoundedNumberError;
476 fn try_from(value: i32) -> Result<Self, Self::Error> {
477 crate::types::bounded_number::BoundedNumber::new(value as f64)
478 }
479}
480impl std::convert::TryFrom<i64> for MaxcpuNum {
481 type Error = crate::types::bounded_number::BoundedNumberError;
482 fn try_from(value: i64) -> Result<Self, Self::Error> {
483 crate::types::bounded_number::BoundedNumber::new(value as f64)
484 }
485}
486impl ::serde::Serialize for MaxcpuNum {
487 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
488 where
489 S: ::serde::Serializer,
490 {
491 crate::types::bounded_number::serialize_bounded_number(self, serializer)
492 }
493}
494impl<'de> ::serde::Deserialize<'de> for MaxcpuNum {
495 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
496 where
497 D: ::serde::Deserializer<'de>,
498 {
499 crate::types::bounded_number::deserialize_bounded_number(deserializer)
500 }
501}