1use manta_backend_dispatcher::types::{
2 Component as FrontEndComponent,
3 ComponentArrayPostArray as FrontEndComponentArrayPostArray,
4 ComponentCreate as FrontEndComponentCreate, NodeMetadataArray,
5};
6
7use serde::{Deserialize, Serialize};
8
9#[derive(Debug, Serialize, Deserialize, Clone)]
10pub struct ComponentArray {
11 #[serde(skip_serializing_if = "Option::is_none")]
12 #[serde(rename = "Components")]
13 pub components: Option<Vec<Component>>,
14}
15
16impl From<NodeMetadataArray> for ComponentArray {
17 fn from(value: NodeMetadataArray) -> Self {
18 let component_vec_opt: Option<Vec<Component>> =
19 if let Some(components) = value.components {
20 let mut component_vec: Vec<Component> =
21 Vec::with_capacity(components.len());
22
23 components
24 .into_iter()
25 .for_each(|component: FrontEndComponent| {
26 component_vec.push(Component::from(component))
27 });
28
29 Some(component_vec)
30 } else {
31 None
32 };
33
34 ComponentArray {
35 components: component_vec_opt,
36 }
37 }
38}
39
40impl Into<NodeMetadataArray> for ComponentArray {
41 fn into(self) -> NodeMetadataArray {
42 let component_vec_opt: Option<Vec<FrontEndComponent>> =
43 if let Some(components) = self.components {
44 let mut component_vec: Vec<FrontEndComponent> =
45 Vec::with_capacity(components.len());
46
47 components.into_iter().for_each(|component: Component| {
48 component_vec.push(component.into())
49 });
50
51 Some(component_vec)
52 } else {
53 None
54 };
55
56 NodeMetadataArray {
57 components: component_vec_opt,
58 }
59 }
60}
61
62#[derive(Debug, Serialize, Deserialize, Clone)]
63pub struct Component {
64 #[serde(skip_serializing_if = "Option::is_none")]
65 #[serde(rename = "ID")]
66 pub id: Option<String>,
67 #[serde(skip_serializing_if = "Option::is_none")]
68 #[serde(rename = "Type")]
69 pub r#type: Option<String>,
70 #[serde(skip_serializing_if = "Option::is_none")]
71 #[serde(rename = "State")]
72 pub state: Option<String>,
73 #[serde(skip_serializing_if = "Option::is_none")]
74 #[serde(rename = "Flag")]
75 pub flag: Option<String>,
76 #[serde(skip_serializing_if = "Option::is_none")]
77 #[serde(rename = "Enabled")]
78 pub enabled: Option<bool>,
79 #[serde(skip_serializing_if = "Option::is_none")]
80 #[serde(rename = "SoftwareStatus")]
81 pub software_status: Option<String>,
82 #[serde(skip_serializing_if = "Option::is_none")]
83 #[serde(rename = "Role")]
84 pub role: Option<String>,
85 #[serde(skip_serializing_if = "Option::is_none")]
86 #[serde(rename = "SubRole")]
87 pub sub_role: Option<String>,
88 #[serde(skip_serializing_if = "Option::is_none")]
89 #[serde(rename = "NID")]
90 pub nid: Option<usize>,
91 #[serde(skip_serializing_if = "Option::is_none")]
92 #[serde(rename = "Subtype")]
93 pub subtype: Option<String>,
94 #[serde(skip_serializing_if = "Option::is_none")]
95 #[serde(rename = "NetType")]
96 pub net_type: Option<String>,
97 #[serde(skip_serializing_if = "Option::is_none")]
98 #[serde(rename = "Arch")]
99 pub arch: Option<String>,
100 #[serde(skip_serializing_if = "Option::is_none")]
101 #[serde(rename = "Class")]
102 pub class: Option<String>,
103 #[serde(skip_serializing_if = "Option::is_none")]
104 #[serde(rename = "ReservationDisabled")]
105 pub reservation_disabled: Option<bool>,
106 #[serde(skip_serializing_if = "Option::is_none")]
107 #[serde(rename = "Locked")]
108 pub locked: Option<bool>,
109}
110
111impl From<FrontEndComponent> for Component {
112 fn from(value: FrontEndComponent) -> Self {
113 Component {
114 id: value.id,
115 r#type: value.r#type,
116 state: value.state,
117 flag: value.flag,
118 enabled: value.enabled,
119 software_status: value.software_status,
120 role: value.role,
121 sub_role: value.sub_role,
122 nid: value.nid,
123 subtype: value.subtype,
124 net_type: value.net_type,
125 arch: value.arch,
126 class: value.class,
127 reservation_disabled: value.reservation_disabled,
128 locked: value.locked,
129 }
130 }
131}
132
133impl Into<FrontEndComponent> for Component {
134 fn into(self) -> FrontEndComponent {
135 FrontEndComponent {
136 id: self.id,
137 r#type: self.r#type,
138 state: self.state,
139 flag: self.flag,
140 enabled: self.enabled,
141 software_status: self.software_status,
142 role: self.role,
143 sub_role: self.sub_role,
144 nid: self.nid,
145 subtype: self.subtype,
146 net_type: self.net_type,
147 arch: self.arch,
148 class: self.class,
149 reservation_disabled: self.reservation_disabled,
150 locked: self.locked,
151 }
152 }
153}
154
155#[derive(Debug, Serialize, Deserialize, Clone)]
156pub struct ComponentArrayPostQuery {
157 #[serde(skip_serializing_if = "Option::is_none")]
158 #[serde(rename(serialize = "ComponentIDs"))]
159 pub component_ids: Option<Vec<String>>,
160 #[serde(skip_serializing_if = "Option::is_none")]
161 pub partition: Option<String>,
162 #[serde(skip_serializing_if = "Option::is_none")]
163 pub group: Option<String>,
164 #[serde(skip_serializing_if = "Option::is_none")]
165 #[serde(rename(serialize = "stateonly"))]
166 pub state_only: Option<bool>,
167 #[serde(skip_serializing_if = "Option::is_none")]
168 #[serde(rename(serialize = "flagonly"))]
169 pub falg_only: Option<bool>,
170 #[serde(skip_serializing_if = "Option::is_none")]
171 #[serde(rename(serialize = "roleonly"))]
172 pub role_only: Option<bool>,
173 #[serde(skip_serializing_if = "Option::is_none")]
174 #[serde(rename(serialize = "nidonly"))]
175 pub nid_only: Option<bool>,
176 #[serde(skip_serializing_if = "Option::is_none")]
177 pub r#type: Option<String>,
178 #[serde(skip_serializing_if = "Option::is_none")]
179 pub state: Option<String>,
180 #[serde(skip_serializing_if = "Option::is_none")]
181 pub flag: Option<String>,
182 #[serde(skip_serializing_if = "Option::is_none")]
183 pub enabled: Option<String>,
184 #[serde(skip_serializing_if = "Option::is_none")]
185 #[serde(rename(serialize = "softwarestatus"))]
186 pub software_status: Option<String>,
187 #[serde(skip_serializing_if = "Option::is_none")]
188 pub role: Option<String>,
189 #[serde(skip_serializing_if = "Option::is_none")]
190 pub subrole: Option<String>,
191 #[serde(skip_serializing_if = "Option::is_none")]
192 pub subtype: Option<String>,
193 #[serde(skip_serializing_if = "Option::is_none")]
194 pub arch: Option<String>,
195 #[serde(skip_serializing_if = "Option::is_none")]
196 pub class: Option<String>,
197 #[serde(skip_serializing_if = "Option::is_none")]
198 pub nid: Option<String>,
199 #[serde(skip_serializing_if = "Option::is_none")]
200 pub nid_start: Option<String>,
201 #[serde(skip_serializing_if = "Option::is_none")]
202 pub nid_end: Option<String>,
203}
204
205#[derive(Debug, Serialize, Deserialize, Clone)]
206pub struct ComponentArrayPostByNidQuery {
207 #[serde(rename(serialize = "NIDRanges"))]
208 pub nid_ranges: Vec<String>,
209 #[serde(skip_serializing_if = "Option::is_none")]
210 pub partition: Option<String>,
211 #[serde(skip_serializing_if = "Option::is_none")]
212 #[serde(rename(serialize = "stateonly"))]
213 pub state_only: Option<bool>,
214 #[serde(skip_serializing_if = "Option::is_none")]
215 #[serde(rename(serialize = "flagonly"))]
216 pub falg_only: Option<bool>,
217 #[serde(skip_serializing_if = "Option::is_none")]
218 #[serde(rename(serialize = "roleonly"))]
219 pub role_only: Option<bool>,
220 #[serde(skip_serializing_if = "Option::is_none")]
221 #[serde(rename(serialize = "nidonly"))]
222 pub nid_only: Option<bool>,
223}
224
225#[derive(Debug, Serialize, Deserialize, Clone)]
226pub struct ComponentArrayPostArray {
227 #[serde(rename(serialize = "Components"))]
228 pub components: Vec<ComponentCreate>,
229 #[serde(skip_serializing_if = "Option::is_none")]
230 #[serde(rename(serialize = "Force"))]
231 pub force: Option<bool>,
232}
233
234impl From<FrontEndComponentArrayPostArray> for ComponentArrayPostArray {
235 fn from(value: FrontEndComponentArrayPostArray) -> Self {
236 let mut component_vec: Vec<ComponentCreate> =
237 Vec::with_capacity(value.components.len());
238
239 value
240 .components
241 .into_iter()
242 .for_each(|c| component_vec.push(ComponentCreate::from(c)));
243
244 ComponentArrayPostArray {
245 components: component_vec,
246 force: value.force,
247 }
248 }
249}
250
251impl Into<FrontEndComponentArrayPostArray> for ComponentArrayPostArray {
252 fn into(self) -> FrontEndComponentArrayPostArray {
253 let mut component_vec: Vec<FrontEndComponentCreate> =
254 Vec::with_capacity(self.components.len());
255
256 self
257 .components
258 .into_iter()
259 .for_each(|c| component_vec.push(c.into()));
260
261 FrontEndComponentArrayPostArray {
262 components: component_vec,
263 force: self.force,
264 }
265 }
266}
267
268#[derive(Debug, Serialize, Deserialize, Clone)]
269pub struct ComponentCreate {
270 #[serde(rename(serialize = "ID"))]
271 id: String,
272 #[serde(rename(serialize = "State"))]
273 state: String,
274 #[serde(skip_serializing_if = "Option::is_none")]
275 #[serde(rename(serialize = "Flag"))]
276 flag: Option<String>,
277 #[serde(skip_serializing_if = "Option::is_none")]
278 #[serde(rename(serialize = "Enabled"))]
279 enabled: Option<bool>,
280 #[serde(skip_serializing_if = "Option::is_none")]
281 #[serde(rename(serialize = "SoftwareStatus"))]
282 software_status: Option<String>,
283 #[serde(skip_serializing_if = "Option::is_none")]
284 #[serde(rename(serialize = "Role"))]
285 role: Option<String>,
286 #[serde(skip_serializing_if = "Option::is_none")]
287 #[serde(rename(serialize = "SubRole"))]
288 sub_role: Option<String>,
289 #[serde(skip_serializing_if = "Option::is_none")]
290 #[serde(rename(serialize = "NID"))]
291 nid: Option<usize>,
292 #[serde(skip_serializing_if = "Option::is_none")]
293 #[serde(rename(serialize = "Subtype"))]
294 subtype: Option<String>,
295 #[serde(skip_serializing_if = "Option::is_none")]
296 #[serde(rename(serialize = "NetType"))]
297 net_type: Option<String>,
298 #[serde(skip_serializing_if = "Option::is_none")]
299 #[serde(rename(serialize = "Arch"))]
300 arch: Option<String>,
301 #[serde(skip_serializing_if = "Option::is_none")]
302 #[serde(rename(serialize = "Class"))]
303 class: Option<String>,
304}
305
306impl From<FrontEndComponentCreate> for ComponentCreate {
307 fn from(value: FrontEndComponentCreate) -> Self {
308 ComponentCreate {
309 id: value.id,
310 state: value.state,
311 flag: value.flag,
312 enabled: value.enabled,
313 software_status: value.software_status,
314 role: value.role,
315 sub_role: value.sub_role,
316 nid: value.nid,
317 subtype: value.subtype,
318 net_type: value.net_type,
319 arch: value.arch,
320 class: value.class,
321 }
322 }
323}
324
325impl Into<FrontEndComponentCreate> for ComponentCreate {
326 fn into(self) -> FrontEndComponentCreate {
327 FrontEndComponentCreate {
328 id: self.id,
329 state: self.state,
330 flag: self.flag,
331 enabled: self.enabled,
332 software_status: self.software_status,
333 role: self.role,
334 sub_role: self.sub_role,
335 nid: self.nid,
336 subtype: self.subtype,
337 net_type: self.net_type,
338 arch: self.arch,
339 class: self.class,
340 }
341 }
342}
343
344#[derive(Debug, Serialize, Deserialize, Clone)]
345pub struct ComponentPut {
346 component: ComponentCreate,
347 #[serde(skip_serializing_if = "Option::is_none")]
348 #[serde(rename(serialize = "Force"))]
349 force: Option<bool>,
350}