ignition_config/v3_2/
schema.rs

1// Generated code; do not modify
2
3#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
4pub struct HttpHeadersItem {
5    pub name: String,
6    #[serde(default)]
7    pub value: Option<String>,
8}
9impl HttpHeadersItem {
10    pub fn new(name: String) -> Self {
11        Self { name, value: None }
12    }
13}
14pub type HttpHeaders = Vec<HttpHeadersItem>;
15#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
16#[serde(rename = "ignition-config")]
17pub struct IgnitionConfig {
18    #[serde(skip_serializing_if = "Option::is_none")]
19    pub merge: Option<Vec<Resource>>,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    pub replace: Option<Resource>,
22}
23#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
24#[serde(rename = "proxy")]
25pub struct Proxy {
26    #[serde(default)]
27    #[serde(rename = "httpProxy")]
28    pub http_proxy: Option<String>,
29    #[serde(default)]
30    #[serde(rename = "httpsProxy")]
31    pub https_proxy: Option<String>,
32    #[serde(skip_serializing_if = "Option::is_none")]
33    #[serde(rename = "noProxy")]
34    pub no_proxy: Option<Vec<Option<String>>>,
35}
36#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
37pub struct SecurityTls {
38    #[serde(skip_serializing_if = "Option::is_none")]
39    #[serde(rename = "certificateAuthorities")]
40    pub certificate_authorities: Option<Vec<Resource>>,
41}
42#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
43#[serde(rename = "security")]
44pub struct Security {
45    #[serde(skip_serializing_if = "Option::is_none")]
46    pub tls: Option<SecurityTls>,
47}
48#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
49#[serde(rename = "timeouts")]
50pub struct Timeouts {
51    #[serde(default)]
52    #[serde(rename = "httpResponseHeaders")]
53    pub http_response_headers: Option<i64>,
54    #[serde(default)]
55    #[serde(rename = "httpTotal")]
56    pub http_total: Option<i64>,
57}
58#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
59#[serde(rename = "ignition")]
60pub struct Ignition {
61    #[serde(skip_serializing_if = "Option::is_none")]
62    pub config: Option<IgnitionConfig>,
63    #[serde(skip_serializing_if = "Option::is_none")]
64    pub proxy: Option<Proxy>,
65    #[serde(skip_serializing_if = "Option::is_none")]
66    pub security: Option<Security>,
67    #[serde(skip_serializing_if = "Option::is_none")]
68    pub timeouts: Option<Timeouts>,
69    #[serde(skip_serializing_if = "Option::is_none")]
70    pub version: Option<String>,
71}
72#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
73#[serde(rename = "group")]
74pub struct Group {
75    #[serde(default)]
76    pub gid: Option<i64>,
77    pub name: String,
78    #[serde(default)]
79    #[serde(rename = "passwordHash")]
80    pub password_hash: Option<String>,
81    #[serde(default)]
82    #[serde(rename = "shouldExist")]
83    pub should_exist: Option<bool>,
84    #[serde(default)]
85    pub system: Option<bool>,
86}
87impl Group {
88    pub fn new(name: String) -> Self {
89        Self {
90            gid: None,
91            name,
92            password_hash: None,
93            should_exist: None,
94            system: None,
95        }
96    }
97}
98#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
99#[serde(rename = "user")]
100pub struct User {
101    #[serde(default)]
102    pub gecos: Option<String>,
103    #[serde(skip_serializing_if = "Option::is_none")]
104    pub groups: Option<Vec<String>>,
105    #[serde(default)]
106    #[serde(rename = "homeDir")]
107    pub home_dir: Option<String>,
108    pub name: String,
109    #[serde(default)]
110    #[serde(rename = "noCreateHome")]
111    pub no_create_home: Option<bool>,
112    #[serde(default)]
113    #[serde(rename = "noLogInit")]
114    pub no_log_init: Option<bool>,
115    #[serde(default)]
116    #[serde(rename = "noUserGroup")]
117    pub no_user_group: Option<bool>,
118    #[serde(default)]
119    #[serde(rename = "passwordHash")]
120    pub password_hash: Option<String>,
121    #[serde(default)]
122    #[serde(rename = "primaryGroup")]
123    pub primary_group: Option<String>,
124    #[serde(default)]
125    pub shell: Option<String>,
126    #[serde(default)]
127    #[serde(rename = "shouldExist")]
128    pub should_exist: Option<bool>,
129    #[serde(skip_serializing_if = "Option::is_none")]
130    #[serde(rename = "sshAuthorizedKeys")]
131    pub ssh_authorized_keys: Option<Vec<String>>,
132    #[serde(default)]
133    pub system: Option<bool>,
134    #[serde(default)]
135    pub uid: Option<i64>,
136}
137impl User {
138    pub fn new(name: String) -> Self {
139        Self {
140            gecos: None,
141            groups: None,
142            home_dir: None,
143            name,
144            no_create_home: None,
145            no_log_init: None,
146            no_user_group: None,
147            password_hash: None,
148            primary_group: None,
149            shell: None,
150            should_exist: None,
151            ssh_authorized_keys: None,
152            system: None,
153            uid: None,
154        }
155    }
156}
157#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
158#[serde(rename = "passwd")]
159pub struct Passwd {
160    #[serde(skip_serializing_if = "Option::is_none")]
161    pub groups: Option<Vec<Group>>,
162    #[serde(skip_serializing_if = "Option::is_none")]
163    pub users: Option<Vec<User>>,
164}
165#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
166#[serde(rename = "resource")]
167pub struct Resource {
168    #[serde(default)]
169    pub compression: Option<String>,
170    #[serde(skip_serializing_if = "Option::is_none")]
171    #[serde(rename = "httpHeaders")]
172    pub http_headers: Option<HttpHeaders>,
173    #[serde(default)]
174    pub source: Option<String>,
175    #[serde(skip_serializing_if = "Option::is_none")]
176    pub verification: Option<Verification>,
177}
178#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
179#[serde(rename = "directory")]
180pub struct Directory {
181    #[serde(skip_serializing_if = "Option::is_none")]
182    pub group: Option<NodeGroup>,
183    #[serde(default)]
184    pub mode: Option<i64>,
185    #[serde(default)]
186    pub overwrite: Option<bool>,
187    pub path: String,
188    #[serde(skip_serializing_if = "Option::is_none")]
189    pub user: Option<NodeUser>,
190}
191impl Directory {
192    pub fn new(path: String) -> Self {
193        Self {
194            group: None,
195            mode: None,
196            overwrite: None,
197            path,
198            user: None,
199        }
200    }
201}
202#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
203#[serde(rename = "disk")]
204pub struct Disk {
205    pub device: String,
206    #[serde(skip_serializing_if = "Option::is_none")]
207    pub partitions: Option<Vec<Partition>>,
208    #[serde(default)]
209    #[serde(rename = "wipeTable")]
210    pub wipe_table: Option<bool>,
211}
212impl Disk {
213    pub fn new(device: String) -> Self {
214        Self {
215            device,
216            partitions: None,
217            wipe_table: None,
218        }
219    }
220}
221#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
222#[serde(rename = "file")]
223pub struct File {
224    #[serde(skip_serializing_if = "Option::is_none")]
225    pub append: Option<Vec<Resource>>,
226    #[serde(skip_serializing_if = "Option::is_none")]
227    pub contents: Option<Resource>,
228    #[serde(skip_serializing_if = "Option::is_none")]
229    pub group: Option<NodeGroup>,
230    #[serde(default)]
231    pub mode: Option<i64>,
232    #[serde(default)]
233    pub overwrite: Option<bool>,
234    pub path: String,
235    #[serde(skip_serializing_if = "Option::is_none")]
236    pub user: Option<NodeUser>,
237}
238impl File {
239    pub fn new(path: String) -> Self {
240        Self {
241            append: None,
242            contents: None,
243            group: None,
244            mode: None,
245            overwrite: None,
246            path,
247            user: None,
248        }
249    }
250}
251#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
252#[serde(rename = "filesystem")]
253pub struct Filesystem {
254    pub device: String,
255    #[serde(default)]
256    pub format: Option<String>,
257    #[serde(default)]
258    pub label: Option<String>,
259    #[serde(skip_serializing_if = "Option::is_none")]
260    #[serde(rename = "mountOptions")]
261    pub mount_options: Option<Vec<String>>,
262    #[serde(skip_serializing_if = "Option::is_none")]
263    pub options: Option<Vec<String>>,
264    #[serde(default)]
265    pub path: Option<String>,
266    #[serde(default)]
267    pub uuid: Option<String>,
268    #[serde(default)]
269    #[serde(rename = "wipeFilesystem")]
270    pub wipe_filesystem: Option<bool>,
271}
272impl Filesystem {
273    pub fn new(device: String) -> Self {
274        Self {
275            device,
276            format: None,
277            label: None,
278            mount_options: None,
279            options: None,
280            path: None,
281            uuid: None,
282            wipe_filesystem: None,
283        }
284    }
285}
286#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
287#[serde(rename = "link")]
288pub struct Link {
289    #[serde(skip_serializing_if = "Option::is_none")]
290    pub group: Option<NodeGroup>,
291    #[serde(default)]
292    pub hard: Option<bool>,
293    #[serde(default)]
294    pub overwrite: Option<bool>,
295    pub path: String,
296    pub target: String,
297    #[serde(skip_serializing_if = "Option::is_none")]
298    pub user: Option<NodeUser>,
299}
300impl Link {
301    pub fn new(path: String, target: String) -> Self {
302        Self {
303            group: None,
304            hard: None,
305            overwrite: None,
306            path,
307            target,
308            user: None,
309        }
310    }
311}
312#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
313pub struct LuksClevisCustom {
314    pub config: String,
315    #[serde(default)]
316    #[serde(rename = "needsNetwork")]
317    pub needs_network: Option<bool>,
318    pub pin: String,
319}
320impl LuksClevisCustom {
321    pub fn new(config: String, pin: String) -> Self {
322        Self {
323            config,
324            needs_network: None,
325            pin,
326        }
327    }
328}
329#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
330pub struct LuksClevis {
331    #[serde(default)]
332    pub custom: Option<LuksClevisCustom>,
333    #[serde(skip_serializing_if = "Option::is_none")]
334    pub tang: Option<Vec<Tang>>,
335    #[serde(default)]
336    pub threshold: Option<i64>,
337    #[serde(default)]
338    #[serde(rename = "tpm2")]
339    pub tpm2: Option<bool>,
340}
341#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
342#[serde(rename = "luks")]
343pub struct Luks {
344    #[serde(default)]
345    pub clevis: Option<LuksClevis>,
346    #[serde(default)]
347    pub device: Option<String>,
348    #[serde(skip_serializing_if = "Option::is_none")]
349    #[serde(rename = "keyFile")]
350    pub key_file: Option<Resource>,
351    #[serde(default)]
352    pub label: Option<String>,
353    pub name: String,
354    #[serde(skip_serializing_if = "Option::is_none")]
355    pub options: Option<Vec<String>>,
356    #[serde(default)]
357    pub uuid: Option<String>,
358    #[serde(default)]
359    #[serde(rename = "wipeVolume")]
360    pub wipe_volume: Option<bool>,
361}
362impl Luks {
363    pub fn new(name: String) -> Self {
364        Self {
365            clevis: None,
366            device: None,
367            key_file: None,
368            label: None,
369            name,
370            options: None,
371            uuid: None,
372            wipe_volume: None,
373        }
374    }
375}
376#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
377pub struct NodeGroup {
378    #[serde(default)]
379    pub id: Option<i64>,
380    #[serde(default)]
381    pub name: Option<String>,
382}
383#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
384pub struct NodeUser {
385    #[serde(default)]
386    pub id: Option<i64>,
387    #[serde(default)]
388    pub name: Option<String>,
389}
390#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
391#[serde(rename = "node")]
392pub struct Node {
393    #[serde(skip_serializing_if = "Option::is_none")]
394    pub group: Option<NodeGroup>,
395    #[serde(default)]
396    pub overwrite: Option<bool>,
397    pub path: String,
398    #[serde(skip_serializing_if = "Option::is_none")]
399    pub user: Option<NodeUser>,
400}
401impl Node {
402    pub fn new(path: String) -> Self {
403        Self {
404            group: None,
405            overwrite: None,
406            path,
407            user: None,
408        }
409    }
410}
411#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
412#[serde(rename = "partition")]
413pub struct Partition {
414    #[serde(default)]
415    pub guid: Option<String>,
416    #[serde(default)]
417    pub label: Option<String>,
418    #[serde(skip_serializing_if = "Option::is_none")]
419    pub number: Option<i64>,
420    #[serde(default)]
421    pub resize: Option<bool>,
422    #[serde(default)]
423    #[serde(rename = "shouldExist")]
424    pub should_exist: Option<bool>,
425    #[serde(default)]
426    #[serde(rename = "sizeMiB")]
427    pub size_mib: Option<i64>,
428    #[serde(default)]
429    #[serde(rename = "startMiB")]
430    pub start_mib: Option<i64>,
431    #[serde(default)]
432    #[serde(rename = "typeGuid")]
433    pub type_guid: Option<String>,
434    #[serde(default)]
435    #[serde(rename = "wipePartitionEntry")]
436    pub wipe_partition_entry: Option<bool>,
437}
438#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
439#[serde(rename = "raid")]
440pub struct Raid {
441    pub devices: Vec<String>,
442    pub level: String,
443    pub name: String,
444    #[serde(skip_serializing_if = "Option::is_none")]
445    pub options: Option<Vec<String>>,
446    #[serde(default)]
447    pub spares: Option<i64>,
448}
449impl Raid {
450    pub fn new(devices: Vec<String>, level: String, name: String) -> Self {
451        Self {
452            devices,
453            level,
454            name,
455            options: None,
456            spares: None,
457        }
458    }
459}
460#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
461#[serde(rename = "tang")]
462pub struct Tang {
463    #[serde(default)]
464    pub thumbprint: Option<String>,
465    #[serde(skip_serializing_if = "Option::is_none")]
466    pub url: Option<String>,
467}
468#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
469#[serde(rename = "storage")]
470pub struct Storage {
471    #[serde(skip_serializing_if = "Option::is_none")]
472    pub directories: Option<Vec<Directory>>,
473    #[serde(skip_serializing_if = "Option::is_none")]
474    pub disks: Option<Vec<Disk>>,
475    #[serde(skip_serializing_if = "Option::is_none")]
476    pub files: Option<Vec<File>>,
477    #[serde(skip_serializing_if = "Option::is_none")]
478    pub filesystems: Option<Vec<Filesystem>>,
479    #[serde(skip_serializing_if = "Option::is_none")]
480    pub links: Option<Vec<Link>>,
481    #[serde(skip_serializing_if = "Option::is_none")]
482    pub luks: Option<Vec<Luks>>,
483    #[serde(skip_serializing_if = "Option::is_none")]
484    pub raid: Option<Vec<Raid>>,
485}
486#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
487#[serde(rename = "dropin")]
488pub struct Dropin {
489    #[serde(default)]
490    pub contents: Option<String>,
491    pub name: String,
492}
493impl Dropin {
494    pub fn new(name: String) -> Self {
495        Self {
496            contents: None,
497            name,
498        }
499    }
500}
501#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
502#[serde(rename = "unit")]
503pub struct Unit {
504    #[serde(default)]
505    pub contents: Option<String>,
506    #[serde(skip_serializing_if = "Option::is_none")]
507    pub dropins: Option<Vec<Dropin>>,
508    #[serde(default)]
509    pub enabled: Option<bool>,
510    #[serde(default)]
511    pub mask: Option<bool>,
512    pub name: String,
513}
514impl Unit {
515    pub fn new(name: String) -> Self {
516        Self {
517            contents: None,
518            dropins: None,
519            enabled: None,
520            mask: None,
521            name,
522        }
523    }
524}
525#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
526#[serde(rename = "systemd")]
527pub struct Systemd {
528    #[serde(skip_serializing_if = "Option::is_none")]
529    pub units: Option<Vec<Unit>>,
530}
531#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
532#[serde(rename = "verification")]
533pub struct Verification {
534    #[serde(default)]
535    pub hash: Option<String>,
536}
537#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
538pub struct Config {
539    pub ignition: Ignition,
540    #[serde(skip_serializing_if = "Option::is_none")]
541    pub passwd: Option<Passwd>,
542    #[serde(skip_serializing_if = "Option::is_none")]
543    pub storage: Option<Storage>,
544    #[serde(skip_serializing_if = "Option::is_none")]
545    pub systemd: Option<Systemd>,
546}
547impl Config {
548    pub fn new(ignition: Ignition) -> Self {
549        Self {
550            ignition,
551            passwd: None,
552            storage: None,
553            systemd: None,
554        }
555    }
556}
ignition_config/v3_2/schema.rs

ignition_config/v3_2/
schema.rs
