ignition_config/v3_6/
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 = "cex")]
201pub struct Cex {
202    #[serde(default)]
203    pub enabled: Option<bool>,
204}
205#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
206#[serde(rename = "clevis")]
207pub struct Clevis {
208    #[serde(skip_serializing_if = "Option::is_none")]
209    pub custom: Option<ClevisCustom>,
210    #[serde(skip_serializing_if = "Option::is_none")]
211    pub tang: Option<Vec<Tang>>,
212    #[serde(default)]
213    pub threshold: Option<i64>,
214    #[serde(default)]
215    #[serde(rename = "tpm2")]
216    pub tpm2: Option<bool>,
217}
218#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
219#[serde(rename = "clevisCustom")]
220pub struct ClevisCustom {
221    #[serde(default)]
222    pub config: Option<String>,
223    #[serde(default)]
224    #[serde(rename = "needsNetwork")]
225    pub needs_network: Option<bool>,
226    #[serde(default)]
227    pub pin: Option<String>,
228}
229#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
230#[serde(rename = "directory")]
231pub struct Directory {
232    #[serde(skip_serializing_if = "Option::is_none")]
233    pub group: Option<NodeGroup>,
234    #[serde(default)]
235    pub mode: Option<i64>,
236    #[serde(default)]
237    pub overwrite: Option<bool>,
238    pub path: String,
239    #[serde(skip_serializing_if = "Option::is_none")]
240    pub user: Option<NodeUser>,
241}
242impl Directory {
243    pub fn new(path: String) -> Self {
244        Self {
245            group: None,
246            mode: None,
247            overwrite: None,
248            path,
249            user: None,
250        }
251    }
252}
253#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
254#[serde(rename = "disk")]
255pub struct Disk {
256    pub device: String,
257    #[serde(skip_serializing_if = "Option::is_none")]
258    pub partitions: Option<Vec<Partition>>,
259    #[serde(default)]
260    #[serde(rename = "wipeTable")]
261    pub wipe_table: Option<bool>,
262}
263impl Disk {
264    pub fn new(device: String) -> Self {
265        Self {
266            device,
267            partitions: None,
268            wipe_table: None,
269        }
270    }
271}
272#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
273#[serde(rename = "file")]
274pub struct File {
275    #[serde(skip_serializing_if = "Option::is_none")]
276    pub append: Option<Vec<Resource>>,
277    #[serde(skip_serializing_if = "Option::is_none")]
278    pub contents: Option<Resource>,
279    #[serde(skip_serializing_if = "Option::is_none")]
280    pub group: Option<NodeGroup>,
281    #[serde(default)]
282    pub mode: Option<i64>,
283    #[serde(default)]
284    pub overwrite: Option<bool>,
285    pub path: String,
286    #[serde(skip_serializing_if = "Option::is_none")]
287    pub user: Option<NodeUser>,
288}
289impl File {
290    pub fn new(path: String) -> Self {
291        Self {
292            append: None,
293            contents: None,
294            group: None,
295            mode: None,
296            overwrite: None,
297            path,
298            user: None,
299        }
300    }
301}
302#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
303#[serde(rename = "filesystem")]
304pub struct Filesystem {
305    pub device: String,
306    #[serde(default)]
307    pub format: Option<String>,
308    #[serde(default)]
309    pub label: Option<String>,
310    #[serde(skip_serializing_if = "Option::is_none")]
311    #[serde(rename = "mountOptions")]
312    pub mount_options: Option<Vec<String>>,
313    #[serde(skip_serializing_if = "Option::is_none")]
314    pub options: Option<Vec<String>>,
315    #[serde(default)]
316    pub path: Option<String>,
317    #[serde(default)]
318    pub uuid: Option<String>,
319    #[serde(default)]
320    #[serde(rename = "wipeFilesystem")]
321    pub wipe_filesystem: Option<bool>,
322}
323impl Filesystem {
324    pub fn new(device: String) -> Self {
325        Self {
326            device,
327            format: None,
328            label: None,
329            mount_options: None,
330            options: None,
331            path: None,
332            uuid: None,
333            wipe_filesystem: None,
334        }
335    }
336}
337#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
338#[serde(rename = "link")]
339pub struct Link {
340    #[serde(skip_serializing_if = "Option::is_none")]
341    pub group: Option<NodeGroup>,
342    #[serde(default)]
343    pub hard: Option<bool>,
344    #[serde(default)]
345    pub overwrite: Option<bool>,
346    pub path: String,
347    #[serde(default)]
348    pub target: Option<String>,
349    #[serde(skip_serializing_if = "Option::is_none")]
350    pub user: Option<NodeUser>,
351}
352impl Link {
353    pub fn new(path: String) -> Self {
354        Self {
355            group: None,
356            hard: None,
357            overwrite: None,
358            path,
359            target: None,
360            user: None,
361        }
362    }
363}
364#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
365#[serde(rename = "luks")]
366pub struct Luks {
367    #[serde(skip_serializing_if = "Option::is_none")]
368    pub cex: Option<Cex>,
369    #[serde(skip_serializing_if = "Option::is_none")]
370    pub clevis: Option<Clevis>,
371    #[serde(default)]
372    pub device: Option<String>,
373    #[serde(default)]
374    pub discard: Option<bool>,
375    #[serde(skip_serializing_if = "Option::is_none")]
376    #[serde(rename = "keyFile")]
377    pub key_file: Option<Resource>,
378    #[serde(default)]
379    pub label: Option<String>,
380    pub name: String,
381    #[serde(skip_serializing_if = "Option::is_none")]
382    #[serde(rename = "openOptions")]
383    pub open_options: Option<Vec<String>>,
384    #[serde(skip_serializing_if = "Option::is_none")]
385    pub options: Option<Vec<String>>,
386    #[serde(default)]
387    pub uuid: Option<String>,
388    #[serde(default)]
389    #[serde(rename = "wipeVolume")]
390    pub wipe_volume: Option<bool>,
391}
392impl Luks {
393    pub fn new(name: String) -> Self {
394        Self {
395            cex: None,
396            clevis: None,
397            device: None,
398            discard: None,
399            key_file: None,
400            label: None,
401            name,
402            open_options: None,
403            options: None,
404            uuid: None,
405            wipe_volume: None,
406        }
407    }
408}
409#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
410pub struct NodeGroup {
411    #[serde(default)]
412    pub id: Option<i64>,
413    #[serde(default)]
414    pub name: Option<String>,
415}
416#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
417pub struct NodeUser {
418    #[serde(default)]
419    pub id: Option<i64>,
420    #[serde(default)]
421    pub name: Option<String>,
422}
423#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
424#[serde(rename = "node")]
425pub struct Node {
426    #[serde(skip_serializing_if = "Option::is_none")]
427    pub group: Option<NodeGroup>,
428    #[serde(default)]
429    pub overwrite: Option<bool>,
430    pub path: String,
431    #[serde(skip_serializing_if = "Option::is_none")]
432    pub user: Option<NodeUser>,
433}
434impl Node {
435    pub fn new(path: String) -> Self {
436        Self {
437            group: None,
438            overwrite: None,
439            path,
440            user: None,
441        }
442    }
443}
444#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
445#[serde(rename = "partition")]
446pub struct Partition {
447    #[serde(default)]
448    pub guid: Option<String>,
449    #[serde(default)]
450    pub label: Option<String>,
451    #[serde(skip_serializing_if = "Option::is_none")]
452    pub number: Option<i64>,
453    #[serde(default)]
454    pub resize: Option<bool>,
455    #[serde(default)]
456    #[serde(rename = "shouldExist")]
457    pub should_exist: Option<bool>,
458    #[serde(default)]
459    #[serde(rename = "sizeMiB")]
460    pub size_mib: Option<i64>,
461    #[serde(default)]
462    #[serde(rename = "startMiB")]
463    pub start_mib: Option<i64>,
464    #[serde(default)]
465    #[serde(rename = "typeGuid")]
466    pub type_guid: Option<String>,
467    #[serde(default)]
468    #[serde(rename = "wipePartitionEntry")]
469    pub wipe_partition_entry: Option<bool>,
470}
471#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
472#[serde(rename = "raid")]
473pub struct Raid {
474    #[serde(skip_serializing_if = "Option::is_none")]
475    pub devices: Option<Vec<String>>,
476    #[serde(default)]
477    pub level: Option<String>,
478    pub name: String,
479    #[serde(skip_serializing_if = "Option::is_none")]
480    pub options: Option<Vec<String>>,
481    #[serde(default)]
482    pub spares: Option<i64>,
483}
484impl Raid {
485    pub fn new(name: String) -> Self {
486        Self {
487            devices: None,
488            level: None,
489            name,
490            options: None,
491            spares: None,
492        }
493    }
494}
495#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
496#[serde(rename = "tang")]
497pub struct Tang {
498    #[serde(default)]
499    pub advertisement: Option<String>,
500    #[serde(default)]
501    pub thumbprint: Option<String>,
502    #[serde(skip_serializing_if = "Option::is_none")]
503    pub url: Option<String>,
504}
505#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
506#[serde(rename = "storage")]
507pub struct Storage {
508    #[serde(skip_serializing_if = "Option::is_none")]
509    pub directories: Option<Vec<Directory>>,
510    #[serde(skip_serializing_if = "Option::is_none")]
511    pub disks: Option<Vec<Disk>>,
512    #[serde(skip_serializing_if = "Option::is_none")]
513    pub files: Option<Vec<File>>,
514    #[serde(skip_serializing_if = "Option::is_none")]
515    pub filesystems: Option<Vec<Filesystem>>,
516    #[serde(skip_serializing_if = "Option::is_none")]
517    pub links: Option<Vec<Link>>,
518    #[serde(skip_serializing_if = "Option::is_none")]
519    pub luks: Option<Vec<Luks>>,
520    #[serde(skip_serializing_if = "Option::is_none")]
521    pub raid: Option<Vec<Raid>>,
522}
523#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
524#[serde(rename = "dropin")]
525pub struct Dropin {
526    #[serde(default)]
527    pub contents: Option<String>,
528    pub name: String,
529}
530impl Dropin {
531    pub fn new(name: String) -> Self {
532        Self {
533            contents: None,
534            name,
535        }
536    }
537}
538#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
539#[serde(rename = "unit")]
540pub struct Unit {
541    #[serde(default)]
542    pub contents: Option<String>,
543    #[serde(skip_serializing_if = "Option::is_none")]
544    pub dropins: Option<Vec<Dropin>>,
545    #[serde(default)]
546    pub enabled: Option<bool>,
547    #[serde(default)]
548    pub mask: Option<bool>,
549    pub name: String,
550}
551impl Unit {
552    pub fn new(name: String) -> Self {
553        Self {
554            contents: None,
555            dropins: None,
556            enabled: None,
557            mask: None,
558            name,
559        }
560    }
561}
562#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
563#[serde(rename = "systemd")]
564pub struct Systemd {
565    #[serde(skip_serializing_if = "Option::is_none")]
566    pub units: Option<Vec<Unit>>,
567}
568#[derive(Clone, PartialEq, Debug, Default, Deserialize, Serialize)]
569#[serde(rename = "verification")]
570pub struct Verification {
571    #[serde(default)]
572    pub hash: Option<String>,
573}
574#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
575pub struct Config {
576    pub ignition: Ignition,
577    #[serde(skip_serializing_if = "Option::is_none")]
578    #[serde(rename = "kernelArguments")]
579    pub kernel_arguments: Option<KernelArguments>,
580    #[serde(skip_serializing_if = "Option::is_none")]
581    pub passwd: Option<Passwd>,
582    #[serde(skip_serializing_if = "Option::is_none")]
583    pub storage: Option<Storage>,
584    #[serde(skip_serializing_if = "Option::is_none")]
585    pub systemd: Option<Systemd>,
586}
587impl Config {
588    pub fn new(ignition: Ignition) -> Self {
589        Self {
590            ignition,
591            kernel_arguments: None,
592            passwd: None,
593            storage: None,
594            systemd: None,
595        }
596    }
597}
ignition_config/v3_6/schema.rs

ignition_config/v3_6/
schema.rs
