ignition_config/v3_0/
schema.rs

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

ignition_config/v3_0/
schema.rs
