proxmox_api/generated/nodes/node/
storage.rs

1pub mod storage;
2pub struct StorageClient<T> {
3    client: T,
4    path: String,
5}
6impl<T> StorageClient<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, "/storage"),
14        }
15    }
16}
17impl<T> StorageClient<T>
18where
19    T: crate::client::Client,
20{
21    #[doc = "Get status for all datastores."]
22    pub fn get(&self, params: GetParams) -> Result<Vec<GetOutputItems>, T::Error> {
23        let path = self.path.to_string();
24        self.client.get(&path, &params)
25    }
26}
27impl GetOutputItems {
28    pub fn new(content: String, storage: String, ty: String) -> Self {
29        Self {
30            content,
31            storage,
32            ty,
33            active: Default::default(),
34            avail: Default::default(),
35            enabled: Default::default(),
36            shared: Default::default(),
37            total: Default::default(),
38            used: Default::default(),
39            used_fraction: Default::default(),
40            additional_properties: Default::default(),
41        }
42    }
43}
44#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
45pub struct GetOutputItems {
46    #[serde(
47        serialize_with = "crate::types::serialize_bool_optional",
48        deserialize_with = "crate::types::deserialize_bool_optional"
49    )]
50    #[serde(skip_serializing_if = "Option::is_none", default)]
51    #[doc = "Set when storage is accessible."]
52    pub active: Option<bool>,
53    #[serde(
54        serialize_with = "crate::types::serialize_int_optional",
55        deserialize_with = "crate::types::deserialize_int_optional"
56    )]
57    #[serde(skip_serializing_if = "Option::is_none", default)]
58    #[doc = "Available storage space in bytes."]
59    pub avail: Option<u64>,
60    #[doc = "Allowed storage content types."]
61    pub content: String,
62    #[serde(
63        serialize_with = "crate::types::serialize_bool_optional",
64        deserialize_with = "crate::types::deserialize_bool_optional"
65    )]
66    #[serde(skip_serializing_if = "Option::is_none", default)]
67    #[doc = "Set when storage is enabled (not disabled)."]
68    pub enabled: Option<bool>,
69    #[serde(
70        serialize_with = "crate::types::serialize_bool_optional",
71        deserialize_with = "crate::types::deserialize_bool_optional"
72    )]
73    #[serde(skip_serializing_if = "Option::is_none", default)]
74    #[doc = "Shared flag from storage configuration."]
75    pub shared: Option<bool>,
76    #[doc = "The storage identifier."]
77    pub storage: String,
78    #[serde(
79        serialize_with = "crate::types::serialize_int_optional",
80        deserialize_with = "crate::types::deserialize_int_optional"
81    )]
82    #[serde(skip_serializing_if = "Option::is_none", default)]
83    #[doc = "Total storage space in bytes."]
84    pub total: Option<u64>,
85    #[serde(rename = "type")]
86    #[doc = "Storage type."]
87    pub ty: String,
88    #[serde(
89        serialize_with = "crate::types::serialize_int_optional",
90        deserialize_with = "crate::types::deserialize_int_optional"
91    )]
92    #[serde(skip_serializing_if = "Option::is_none", default)]
93    #[doc = "Used storage space in bytes."]
94    pub used: Option<u64>,
95    #[serde(
96        serialize_with = "crate::types::serialize_number_optional",
97        deserialize_with = "crate::types::deserialize_number_optional"
98    )]
99    #[serde(skip_serializing_if = "Option::is_none", default)]
100    #[doc = "Used fraction (used/total)."]
101    pub used_fraction: Option<f64>,
102    #[serde(
103        flatten,
104        default,
105        skip_serializing_if = "::std::collections::HashMap::is_empty"
106    )]
107    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
108}
109#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, Default)]
110pub struct GetParams {
111    #[serde(skip_serializing_if = "Option::is_none", default)]
112    #[doc = "Only list stores which support this content type."]
113    pub content: Option<String>,
114    #[serde(
115        serialize_with = "crate::types::serialize_bool_optional",
116        deserialize_with = "crate::types::deserialize_bool_optional"
117    )]
118    #[serde(skip_serializing_if = "Option::is_none", default)]
119    #[doc = "Only list stores which are enabled (not disabled in config)."]
120    pub enabled: Option<bool>,
121    #[serde(
122        serialize_with = "crate::types::serialize_bool_optional",
123        deserialize_with = "crate::types::deserialize_bool_optional"
124    )]
125    #[serde(skip_serializing_if = "Option::is_none", default)]
126    #[doc = "Include information about formats"]
127    pub format: Option<bool>,
128    #[serde(skip_serializing_if = "Option::is_none", default)]
129    #[doc = "Only list status for  specified storage"]
130    pub storage: Option<String>,
131    #[serde(skip_serializing_if = "Option::is_none", default)]
132    #[doc = "If target is different to 'node', we only lists shared storages which content is accessible on this 'node' and the specified 'target' node."]
133    pub target: Option<String>,
134    #[serde(
135        flatten,
136        default,
137        skip_serializing_if = "::std::collections::HashMap::is_empty"
138    )]
139    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
140}
141impl<T> StorageClient<T>
142where
143    T: crate::client::Client,
144{
145    pub fn storage(&self, storage: &str) -> storage::StorageClient<T> {
146        storage::StorageClient::<T>::new(self.client.clone(), &self.path, storage)
147    }
148}