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

ignition_config/v3_4/
schema.rs
