proxmox_api/generated/nodes/node/disks/
zfs.rs

1pub mod name;
2#[derive(Debug, Clone)]
3pub struct ZfsClient<T> {
4    client: T,
5    path: String,
6}
7impl<T> ZfsClient<T>
8where
9    T: crate::client::Client,
10{
11    pub fn new(client: T, parent_path: &str) -> Self {
12        Self {
13            client,
14            path: format!("{}{}", parent_path, "/zfs"),
15        }
16    }
17}
18impl<T> ZfsClient<T>
19where
20    T: crate::client::Client,
21{
22    #[doc = "List Zpools."]
23    #[doc = ""]
24    #[doc = "Permission check: perm(\"/\", [\"Sys.Audit\"])"]
25    pub async fn get(&self) -> Result<Vec<GetOutputItems>, T::Error> {
26        let path = self.path.to_string();
27        let optional_vec: Option<Vec<GetOutputItems>> = self.client.get(&path, &()).await?;
28        Ok(optional_vec.unwrap_or_default())
29    }
30}
31impl<T> ZfsClient<T>
32where
33    T: crate::client::Client,
34{
35    #[doc = "Create a ZFS pool."]
36    #[doc = ""]
37    #[doc = "Permission check: perm(\"/\", [\"Sys.Modify\"])"]
38    #[doc = "Requires additionally 'Datastore.Allocate' on /storage when setting 'add_storage'"]
39    pub async fn post(&self, params: PostParams) -> Result<String, T::Error> {
40        let path = self.path.to_string();
41        self.client.post(&path, &params).await
42    }
43}
44impl GetOutputItems {
45    pub fn new(
46        alloc: i64,
47        dedup: f64,
48        frag: i64,
49        free: i64,
50        health: String,
51        name: String,
52        size: i64,
53    ) -> Self {
54        Self {
55            alloc,
56            dedup,
57            frag,
58            free,
59            health,
60            name,
61            size,
62            additional_properties: ::std::default::Default::default(),
63        }
64    }
65}
66#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
67pub struct GetOutputItems {
68    #[serde(
69        serialize_with = "crate::types::serialize_int",
70        deserialize_with = "crate::types::deserialize_int"
71    )]
72    pub alloc: i64,
73    #[serde(
74        serialize_with = "crate::types::serialize_number",
75        deserialize_with = "crate::types::deserialize_number"
76    )]
77    pub dedup: f64,
78    #[serde(
79        serialize_with = "crate::types::serialize_int",
80        deserialize_with = "crate::types::deserialize_int"
81    )]
82    pub frag: i64,
83    #[serde(
84        serialize_with = "crate::types::serialize_int",
85        deserialize_with = "crate::types::deserialize_int"
86    )]
87    pub free: i64,
88    pub health: String,
89    pub name: String,
90    #[serde(
91        serialize_with = "crate::types::serialize_int",
92        deserialize_with = "crate::types::deserialize_int"
93    )]
94    pub size: i64,
95    #[serde(
96        flatten,
97        default,
98        skip_serializing_if = "::std::collections::HashMap::is_empty"
99    )]
100    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
101}
102impl PostParams {
103    pub fn new(devices: String, name: String, raidlevel: Raidlevel) -> Self {
104        Self {
105            devices,
106            name,
107            raidlevel,
108            add_storage: ::std::default::Default::default(),
109            ashift: ::std::default::Default::default(),
110            compression: ::std::default::Default::default(),
111            draid_config: ::std::default::Default::default(),
112            additional_properties: ::std::default::Default::default(),
113        }
114    }
115}
116#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
117pub struct PostParams {
118    #[serde(
119        serialize_with = "crate::types::serialize_bool_optional",
120        deserialize_with = "crate::types::deserialize_bool_optional"
121    )]
122    #[serde(skip_serializing_if = "Option::is_none", default)]
123    #[doc = "Configure storage using the zpool."]
124    #[doc = ""]
125    pub add_storage: Option<bool>,
126    #[serde(skip_serializing_if = "Option::is_none", default)]
127    #[doc = "Pool sector size exponent."]
128    #[doc = ""]
129    pub ashift: Option<AshiftInt>,
130    #[serde(skip_serializing_if = "Option::is_none", default)]
131    #[doc = "The compression algorithm to use."]
132    #[doc = ""]
133    pub compression: Option<Compression>,
134    #[doc = "The block devices you want to create the zpool on."]
135    #[doc = ""]
136    pub devices: String,
137    #[serde(rename = "draid-config")]
138    #[serde(skip_serializing_if = "Option::is_none", default)]
139    pub draid_config: Option<String>,
140    #[doc = "The storage identifier."]
141    #[doc = ""]
142    pub name: String,
143    #[doc = "The RAID level to use."]
144    #[doc = ""]
145    pub raidlevel: Raidlevel,
146    #[serde(
147        flatten,
148        default,
149        skip_serializing_if = "::std::collections::HashMap::is_empty"
150    )]
151    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
152}
153#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq, Default)]
154#[doc = "The compression algorithm to use."]
155#[doc = ""]
156pub enum Compression {
157    #[serde(rename = "gzip")]
158    Gzip,
159    #[serde(rename = "lz4")]
160    Lz4,
161    #[serde(rename = "lzjb")]
162    Lzjb,
163    #[serde(rename = "off")]
164    Off,
165    #[serde(rename = "on")]
166    #[default]
167    On,
168    #[serde(rename = "zle")]
169    Zle,
170    #[serde(rename = "zstd")]
171    Zstd,
172}
173impl TryFrom<&str> for Compression {
174    type Error = String;
175    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
176        match value {
177            "gzip" => Ok(Self::Gzip),
178            "lz4" => Ok(Self::Lz4),
179            "lzjb" => Ok(Self::Lzjb),
180            "off" => Ok(Self::Off),
181            "on" => Ok(Self::On),
182            "zle" => Ok(Self::Zle),
183            "zstd" => Ok(Self::Zstd),
184            v => Err(format!("Unknown variant {v}")),
185        }
186    }
187}
188#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
189#[doc = "The RAID level to use."]
190#[doc = ""]
191pub enum Raidlevel {
192    #[serde(rename = "draid")]
193    Draid,
194    #[serde(rename = "draid2")]
195    Draid2,
196    #[serde(rename = "draid3")]
197    Draid3,
198    #[serde(rename = "mirror")]
199    Mirror,
200    #[serde(rename = "raid10")]
201    Raid10,
202    #[serde(rename = "raidz")]
203    Raidz,
204    #[serde(rename = "raidz2")]
205    Raidz2,
206    #[serde(rename = "raidz3")]
207    Raidz3,
208    #[serde(rename = "single")]
209    Single,
210}
211impl TryFrom<&str> for Raidlevel {
212    type Error = String;
213    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
214        match value {
215            "draid" => Ok(Self::Draid),
216            "draid2" => Ok(Self::Draid2),
217            "draid3" => Ok(Self::Draid3),
218            "mirror" => Ok(Self::Mirror),
219            "raid10" => Ok(Self::Raid10),
220            "raidz" => Ok(Self::Raidz),
221            "raidz2" => Ok(Self::Raidz2),
222            "raidz3" => Ok(Self::Raidz3),
223            "single" => Ok(Self::Single),
224            v => Err(format!("Unknown variant {v}")),
225        }
226    }
227}
228#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
229pub struct AshiftInt(i128);
230impl crate::types::bounded_integer::BoundedInteger for AshiftInt {
231    const MIN: Option<i128> = Some(9i128);
232    const MAX: Option<i128> = Some(16i128);
233    const DEFAULT: Option<i128> = Some(12i128);
234    const TYPE_DESCRIPTION: &'static str = "an integer between 9 and 16";
235    fn get(&self) -> i128 {
236        self.0
237    }
238    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
239        Self::validate(value)?;
240        Ok(Self(value))
241    }
242}
243impl std::convert::TryFrom<i128> for AshiftInt {
244    type Error = crate::types::bounded_integer::BoundedIntegerError;
245    fn try_from(value: i128) -> Result<Self, Self::Error> {
246        crate::types::bounded_integer::BoundedInteger::new(value)
247    }
248}
249impl ::serde::Serialize for AshiftInt {
250    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
251    where
252        S: ::serde::Serializer,
253    {
254        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
255    }
256}
257impl<'de> ::serde::Deserialize<'de> for AshiftInt {
258    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
259    where
260        D: ::serde::Deserializer<'de>,
261    {
262        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
263    }
264}
265impl<T> ZfsClient<T>
266where
267    T: crate::client::Client,
268{
269    pub fn name(&self, name: &str) -> name::NameClient<T> {
270        name::NameClient::<T>::new(self.client.clone(), &self.path, name)
271    }
272}
proxmox_api/generated/nodes/node/disks/zfs.rs

proxmox_api/generated/nodes/node/disks/
zfs.rs
