manta_backend_dispatcher/types/
mod.rs

1pub mod bos;
2pub mod bss;
3pub mod cfs;
4pub mod hsm;
5pub mod ims;
6pub mod kafka;
7pub mod pcs;
8
9use std::str::FromStr;
10
11use serde::{Deserialize, Serialize};
12use serde_json::Value;
13use strum_macros::{AsRefStr, Display, EnumIter, EnumString, IntoStaticStr};
14
15
16#[derive(Serialize, Deserialize, Debug, Clone)]
17pub enum K8sAuth {
18  #[serde(rename = "native")]
19  Native {
20    certificate_authority_data: String,
21    client_certificate_data: String,
22    client_key_data: String,
23  },
24  #[serde(rename = "vault")]
25  Vault { base_url: String },
26}
27
28#[derive(Serialize, Deserialize, Debug, Clone)]
29pub struct K8sDetails {
30  pub api_url: String,
31  pub authentication: K8sAuth,
32}
33
34// From CSM used by Manta
35#[derive(
36  Debug,
37  EnumIter,
38  EnumString,
39  IntoStaticStr,
40  AsRefStr,
41  Display,
42  Serialize,
43  Deserialize,
44  Clone,
45)]
46pub enum ArtifactType {
47  Memory,
48  Processor,
49  NodeAccel,
50  NodeHsnNic,
51  Drive,
52  CabinetPDU,
53  CabinetPDUPowerConnector,
54  CMMRectifier,
55  NodeAccelRiser,
56  NodeEnclosurePowerSupplie,
57  NodeBMC,
58  RouterBMC,
59}
60
61#[derive(Default, Debug, Serialize, Deserialize, Clone)]
62pub struct NodeSummary {
63  pub xname: String,
64  pub r#type: String,
65  pub processors: Vec<ArtifactSummary>,
66  pub memory: Vec<ArtifactSummary>,
67  pub node_accels: Vec<ArtifactSummary>,
68  pub node_hsn_nics: Vec<ArtifactSummary>,
69}
70
71/* impl From<HWInventoryByLocation> for NodeSummary {
72    fn from(value: HWInventoryByLocation) -> Self {
73        NodeSummary {
74            xname: value.id,
75            r#type: value.r#type.unwrap_or_default(),
76            processors: value
77                .processors
78                .unwrap_or_default()
79                .into_iter()
80                .map(ArtifactSummary::from)
81                .collect(),
82            // FIXME: implement FROM trait from HWInvByLlocProcessor to ArtifactSummary
83            memory: value
84                .memory
85                .unwrap_or_default()
86                .into_iter()
87                .map(ArtifactSummary::from)
88                .collect(),
89            // FIXME: implement FROM trait from HWInvByLlocMemory to ArtifactSummary
90            node_accels: value
91                .node_accels
92                .unwrap_or_default()
93                .into_iter()
94                .map(ArtifactSummary::from)
95                .collect(),
96            // FIXME: implement FROM trait from HWInvByLlocNodeAccel to ArtifactSummary
97            node_hsn_nics: value
98                .node_hsn_nics
99                .unwrap_or_default()
100                .into_iter()
101                .map(ArtifactSummary::from)
102                .collect(),
103            // FIXME: implement FROM trait from HWInvByLlocHSNNIC to ArtifactSummary
104        }
105    }
106}
107
108impl Into<HWInventoryByLocation> for NodeSummary {
109    fn into(self) -> HWInventoryByLocation {
110        let redfish_system_fru_info = RedfishSystemFRUInfo {
111            asset_tag: None,
112            bios_version: None,
113            model: None,
114            manufacturer: None,
115            part_number: None,
116            serial_number: None,
117            sku: None,
118            system_type: None,
119            uuid: None,
120        };
121
122        let hw_inv_by_fr_node = HWInvByFRUNode {
123            fru_id: None,
124            r#type: None,
125            fru_sub_type: None,
126            hw_inventory_by_fru_type: self.r#type.clone(),
127            node_fru_info: redfish_system_fru_info,
128        };
129
130        let processor_summary = ProcessorSummary {
131            count: self.processors.len().try_into().ok(),
132            model: self.processors.first().unwrap().info.clone(),
133        };
134
135        let memory_capacity_vec: Vec<usize> = self
136            .memory
137            .iter()
138            .map(|memory| {
139                let binding = "".to_string();
140                let mem_capacity = memory.info.as_ref().unwrap_or(&binding);
141                /* .strip_suffix(" MiB")
142                .unwrap_or_default(); */
143
144                usize::from_str(mem_capacity.strip_suffix(" MiB").unwrap_or_default())
145                    .unwrap_or_default()
146            })
147            .collect();
148
149        let memory_summary = MemorySummary {
150            total_system_memory_gib: Some(memory_capacity_vec.iter().sum::<usize>() as u32),
151        };
152
153        let node_location_info = NodeLocationInfo {
154            id: self.xname.clone(),
155            name: None,
156            description: None,
157            hostname: None,
158            processor_summary: Some(processor_summary),
159            memory_summary: Some(memory_summary),
160        };
161
162        HWInventoryByLocation {
163            id: self.xname,
164            r#type: Some(self.r#type.clone()),
165            ordinal: None,
166            status: None,
167            node_location_info,
168            hw_inventory_by_location_type: self.r#type,
169            populated_fru: Some(hw_inv_by_fr_node),
170            cabinets: None,
171            chassis: None,
172            compute_modules: None,
173            router_modules: None,
174            node_enclosures: None,
175            hsn_boards: None,        // FIXME: implement!
176            mgmt_switches: None,     // FIXME: implement!
177            mgmt_hl_switches: None,  // FIXME: implement!
178            cdu_mgmt_switches: None, // FIXME: implement!
179            nodes: None,             // FIXME: implement!
180            processors: Some(
181                self.processors
182                    .into_iter()
183                    .map(|processor| processor.into())
184                    .collect(),
185            ), // FIXME: implement!
186            node_accels: Some(
187                self.node_accels
188                    .into_iter()
189                    .map(|node_accel| node_accel.into())
190                    .collect(),
191            ), // FIXME: implement!
192            drives: None,            // FIXME: implement!
193            memory: Some(
194                self.memory
195                    .into_iter()
196                    .map(|memory| memory.into())
197                    .collect(),
198            ), // FIXME: implement!
199            cabinet_pdus: None,      // FIXME: implement!
200            cabinet_pdu_power_connectors: None, // FIXME: implement!
201            cmm_rectifiers: None,    // FIXME: implement!
202            node_accel_risers: None, // FIXME: implement!
203            node_hsn_nics: Some(
204                self.node_hsn_nics
205                    .into_iter()
206                    .map(|node_hsn_nic| node_hsn_nic.into())
207                    .collect(),
208            ), // FIXME: implement!
209            node_enclosure_power_supplies: None, // FIXME: implement!
210            node_bmc: None,
211            router_bmc: None, // FIXME: implement!
212        }
213    }
214} */
215
216impl From<HWInvByLocNode> for NodeSummary {
217  fn from(value: HWInvByLocNode) -> Self {
218    NodeSummary {
219      xname: value.id,
220      r#type: value.r#type.unwrap_or_default(),
221      processors: value
222        .processors
223        .unwrap_or_default()
224        .into_iter()
225        .map(ArtifactSummary::from)
226        .collect(),
227      // FIXME: implement FROM trait from HWInvByLlocProcessor to ArtifactSummary
228      memory: value
229        .memory
230        .unwrap_or_default()
231        .into_iter()
232        .map(ArtifactSummary::from)
233        .collect(),
234      // FIXME: implement FROM trait from HWInvByLlocMemory to ArtifactSummary
235      node_accels: value
236        .node_accels
237        .unwrap_or_default()
238        .into_iter()
239        .map(ArtifactSummary::from)
240        .collect(),
241      // FIXME: implement FROM trait from HWInvByLlocNodeAccel to ArtifactSummary
242      node_hsn_nics: value
243        .node_hsn_nics
244        .unwrap_or_default()
245        .into_iter()
246        .map(ArtifactSummary::from)
247        .collect(),
248      // FIXME: implement FROM trait from HWInvByLlocHSNNIC to ArtifactSummary
249    }
250  }
251}
252
253impl Into<HWInvByLocNode> for NodeSummary {
254  fn into(self) -> HWInvByLocNode {
255    let redfish_system_fru_info = RedfishSystemFRUInfo {
256      asset_tag: None,
257      bios_version: None,
258      model: None,
259      manufacturer: None,
260      part_number: None,
261      serial_number: None,
262      sku: None,
263      system_type: None,
264      uuid: None,
265    };
266
267    let hw_inv_by_fr_node = HWInvByFRUNode {
268      fru_id: None,
269      r#type: None,
270      fru_sub_type: None,
271      hw_inventory_by_fru_type: self.r#type.clone(),
272      node_fru_info: redfish_system_fru_info,
273    };
274
275    HWInvByLocNode {
276      id: self.xname,
277      r#type: Some(self.r#type.clone()),
278      ordinal: None,
279      status: None,
280      hw_inventory_by_location_type: self.r#type,
281      populated_fru: Some(hw_inv_by_fr_node),
282      node_location_info: None,
283      processors: Some(
284        self
285          .processors
286          .into_iter()
287          .map(|processor| processor.into())
288          .collect(),
289      ),
290      node_accels: Some(
291        self
292          .node_accels
293          .into_iter()
294          .map(|node_accel| node_accel.into())
295          .collect(),
296      ),
297      drives: None,
298      memory: Some(
299        self
300          .memory
301          .into_iter()
302          .map(|memory| memory.into())
303          .collect(),
304      ),
305      node_accel_risers: None,
306      node_hsn_nics: Some(
307        self
308          .node_hsn_nics
309          .into_iter()
310          .map(|node_hsn_nic| node_hsn_nic.into())
311          .collect(),
312      ),
313    }
314  }
315}
316
317impl NodeSummary {
318  pub fn from_csm_value(hw_artifact_value: Value) -> Self {
319    let processors = hw_artifact_value["Processors"]
320      .as_array()
321      .unwrap_or(&Vec::new())
322      .iter()
323      .map(|processor_value| {
324        ArtifactSummary::from_processor_value(processor_value.clone())
325      })
326      .collect();
327
328    let memory = hw_artifact_value["Memory"]
329      .as_array()
330      .unwrap_or(&Vec::new())
331      .iter()
332      .map(|memory_value| {
333        ArtifactSummary::from_memory_value(memory_value.clone())
334      })
335      .collect();
336
337    let node_accels = hw_artifact_value["NodeAccels"]
338      .as_array()
339      .unwrap_or(&Vec::new())
340      .iter()
341      .map(|nodeaccel_value| {
342        ArtifactSummary::from_nodeaccel_value(nodeaccel_value.clone())
343      })
344      .collect();
345
346    let node_hsn_nics = hw_artifact_value["NodeHsnNics"]
347      .as_array()
348      .unwrap_or(&Vec::new())
349      .iter()
350      .map(|nodehsnnic_value| {
351        ArtifactSummary::from_nodehsnnics_value(nodehsnnic_value.clone())
352      })
353      .collect();
354
355    Self {
356      xname: hw_artifact_value["ID"].as_str().unwrap().to_string(),
357      r#type: hw_artifact_value["Type"].as_str().unwrap().to_string(),
358      processors,
359      memory,
360      node_accels,
361      node_hsn_nics,
362    }
363  }
364}
365
366#[derive(Debug, Serialize, Deserialize, Clone)]
367pub struct ArtifactSummary {
368  pub xname: String,
369  pub r#type: ArtifactType,
370  pub info: Option<String>,
371}
372
373impl From<HWInvByLocProcessor> for ArtifactSummary {
374  fn from(value: HWInvByLocProcessor) -> Self {
375    ArtifactSummary {
376      xname: value.id,
377      r#type: ArtifactType::from_str(value.r#type.unwrap().as_str()).unwrap(),
378      info: value.populated_fru.and_then(|hw_inv_by_fru_processor| {
379        hw_inv_by_fru_processor.processor_fru_info.model
380      }),
381    }
382  }
383}
384
385impl Into<HWInvByLocProcessor> for ArtifactSummary {
386  fn into(self) -> HWInvByLocProcessor {
387    let redfish_process_fru_info = RedfishProcessorFRUInfo {
388      instruction_set: None,
389      manufacturer: None,
390      max_speed_mhz: None,
391      model: self.info,
392      processor_architecture: None,
393      processor_id: None,
394      processor_type: None,
395      total_cores: None,
396      total_threads: None,
397    };
398
399    let hw_inv_by_fru_processor = HWInvByFRUProcessor {
400      fru_id: None,
401      r#type: Some(self.r#type.to_string()),
402      fru_sub_type: None,
403      hw_inventory_by_fru_type: self.r#type.to_string(),
404      processor_fru_info: redfish_process_fru_info,
405    };
406
407    let processor_location_info = RedfishProcessorLocationInfo {
408      id: None,
409      name: None,
410      description: None,
411      socket: None,
412    };
413
414    HWInvByLocProcessor {
415      id: self.xname,
416      r#type: Some(self.r#type.to_string()),
417      ordinal: None,
418      status: None,
419      hw_inventory_by_location_type: self.r#type.to_string(),
420      populated_fru: Some(hw_inv_by_fru_processor),
421      processor_location_info,
422    }
423  }
424}
425
426impl From<HWInvByLocMemory> for ArtifactSummary {
427  fn from(value: HWInvByLocMemory) -> Self {
428    ArtifactSummary {
429      xname: value.id,
430      r#type: ArtifactType::from_str(value.r#type.unwrap().as_str()).unwrap(),
431      info: value.populated_fru.and_then(|hw_inv_by_fru_memory| {
432        hw_inv_by_fru_memory
433          .memory_fru_info
434          .capacity_mib
435          .map(|capacity_mib| capacity_mib.to_string())
436      }),
437    }
438  }
439}
440
441impl Into<HWInvByLocMemory> for ArtifactSummary {
442  fn into(self) -> HWInvByLocMemory {
443    let redfish_memory_fru_info = RedfishMemoryFRUInfo {
444      base_module_type: None,
445      bus_width_bits: None,
446      capacity_mib: self.info.map(|info| usize::from_str(&info).unwrap_or(0)), // FIXME:
447      // settings memory capacity to 0 if any issue... this does not look ok...
448      data_width_bits: None,
449      error_correction: None,
450      manufacturer: None,
451      memory_type: None,
452      memory_device_type: None,
453      operating_speed_mhz: None,
454      part_number: None,
455      rank_count: None,
456      serial_number: None,
457    };
458
459    let hw_inv_by_fru_memory = HWInvByFRUMemory {
460      fru_id: None,
461      r#type: Some(self.r#type.to_string()),
462      fru_sub_type: None,
463      hw_inventory_by_fru_type: self.r#type.to_string(),
464      memory_fru_info: redfish_memory_fru_info,
465    };
466
467    let memory_location = MemoryLocation {
468      socket: None,
469      memory_controller: None,
470      channel: None,
471      slot: None,
472    };
473
474    let redfish_memory_location_info = RedfishMemoryLocationInfo {
475      id: None,
476      name: None,
477      description: None,
478      memory_location: Some(memory_location),
479    };
480
481    HWInvByLocMemory {
482      id: self.xname,
483      r#type: Some(self.r#type.to_string()),
484      ordinal: None,
485      status: None,
486      hw_inventory_by_location_type: self.r#type.to_string(),
487      populated_fru: Some(hw_inv_by_fru_memory),
488      memory_location_info: redfish_memory_location_info,
489    }
490  }
491}
492
493impl From<HWInvByLocNodeAccel> for ArtifactSummary {
494  fn from(value: HWInvByLocNodeAccel) -> Self {
495    ArtifactSummary {
496      xname: value.id,
497      r#type: ArtifactType::from_str(value.r#type.unwrap().as_str()).unwrap(),
498      info: value.populated_fru.and_then(|hw_inv_by_fru_node_accel| {
499        hw_inv_by_fru_node_accel.node_accel_fru_info.model
500      }),
501    }
502  }
503}
504
505impl Into<HWInvByLocNodeAccel> for ArtifactSummary {
506  fn into(self) -> HWInvByLocNodeAccel {
507    // NOTE: yes, sounds weird FRU for node accelerator uses FRU for processor... but that is
508    // what the API docs says...
509    let redfish_processor_fru_info = RedfishProcessorFRUInfo {
510      instruction_set: None,
511      manufacturer: None,
512      max_speed_mhz: None,
513      model: self.info,
514      processor_architecture: None,
515      processor_id: None,
516      processor_type: None,
517      total_cores: None,
518      total_threads: None,
519    };
520
521    let hw_inv_by_fru_node_accel = HWInvByFRUNodeAccel {
522      fru_id: None,
523      r#type: Some(self.r#type.to_string()),
524      fru_sub_type: None,
525      hw_inventory_by_fru_type: self.r#type.to_string(),
526      node_accel_fru_info: redfish_processor_fru_info,
527    };
528
529    HWInvByLocNodeAccel {
530      id: self.xname,
531      r#type: Some(self.r#type.to_string()),
532      ordinal: None,
533      status: None,
534      hw_inventory_by_location_type: self.r#type.to_string(),
535      populated_fru: Some(hw_inv_by_fru_node_accel),
536      node_accel_location_info: None,
537    }
538  }
539}
540
541impl From<HWInvByLocHSNNIC> for ArtifactSummary {
542  fn from(value: HWInvByLocHSNNIC) -> Self {
543    ArtifactSummary {
544      xname: value.id,
545      r#type: ArtifactType::from_str(value.r#type.unwrap().as_str()).unwrap(),
546      info: value.populated_fru.and_then(|hw_inv_by_fru_hsn_nic| {
547        hw_inv_by_fru_hsn_nic.hsn_nic_fru_info.model
548      }),
549    }
550  }
551}
552
553impl Into<HWInvByLocHSNNIC> for ArtifactSummary {
554  fn into(self) -> HWInvByLocHSNNIC {
555    // NOTE: yes, sounds weird FRU for node accelerator uses FRU for processor... but that is
556    // what the API docs says...
557    let hsn_nic_fru_info = HSNNICFRUInfo {
558      manufacturer: None,
559      model: self.info,
560      part_number: None,
561      sku: None,
562      serial_number: None,
563    };
564
565    let hw_inv_by_fru_hsn_nic = HWInvByFRUHSNNIC {
566      fru_id: None,
567      r#type: Some(self.r#type.to_string()),
568      fru_sub_type: None,
569      hw_inventory_by_fru_type: self.r#type.to_string(),
570      hsn_nic_fru_info,
571    };
572
573    let hsn_nic_location_info = HSNNICLocationInfo {
574      id: None,
575      name: None,
576      description: None,
577    };
578
579    HWInvByLocHSNNIC {
580      id: self.xname,
581      r#type: Some(self.r#type.to_string()),
582      ordinal: None,
583      status: None,
584      hw_inventory_by_location_type: self.r#type.to_string(),
585      populated_fru: Some(hw_inv_by_fru_hsn_nic),
586      hsn_nic_location_info,
587    }
588  }
589}
590
591impl ArtifactSummary {
592  fn from_processor_value(processor_value: Value) -> Self {
593    Self {
594      xname: processor_value["ID"].as_str().unwrap().to_string(),
595      r#type: ArtifactType::from_str(processor_value["Type"].as_str().unwrap())
596        .unwrap(),
597      info: processor_value
598        .pointer("/PopulatedFRU/ProcessorFRUInfo/Model")
599        .map(|model| model.as_str().unwrap().to_string()),
600    }
601  }
602
603  fn from_memory_value(memory_value: Value) -> Self {
604    Self {
605      xname: memory_value["ID"].as_str().unwrap().to_string(),
606      r#type: ArtifactType::from_str(memory_value["Type"].as_str().unwrap())
607        .unwrap(),
608      info: memory_value
609        .pointer("/PopulatedFRU/MemoryFRUInfo/CapacityMiB")
610        .map(|capacity_mib| {
611          capacity_mib.as_number().unwrap().to_string() + " MiB"
612        }),
613    }
614  }
615
616  fn from_nodehsnnics_value(nodehsnnic_value: Value) -> Self {
617    Self {
618      xname: nodehsnnic_value["ID"].as_str().unwrap().to_string(),
619      r#type: ArtifactType::from_str(
620        nodehsnnic_value["Type"].as_str().unwrap(),
621      )
622      .unwrap(),
623      info: nodehsnnic_value
624        .pointer("/NodeHsnNicLocationInfo/Description")
625        .map(|description| description.as_str().unwrap().to_string()),
626    }
627  }
628
629  fn from_nodeaccel_value(nodeaccel_value: Value) -> Self {
630    Self {
631      xname: nodeaccel_value["ID"].as_str().unwrap().to_string(),
632      r#type: ArtifactType::from_str(nodeaccel_value["Type"].as_str().unwrap())
633        .unwrap(),
634      info: nodeaccel_value
635        .pointer("/PopulatedFRU/NodeAccelFRUInfo/Model")
636        .map(|model| model.as_str().unwrap().to_string()),
637    }
638  }
639}
640
641// From OCHAMI API
642#[derive(Debug, Serialize, Deserialize, Clone)]
643pub struct Group {
644  pub label: String,
645  #[serde(skip_serializing_if = "Option::is_none")]
646  pub description: Option<String>,
647  #[serde(skip_serializing_if = "Option::is_none")]
648  pub tags: Option<Vec<String>>,
649  #[serde(skip_serializing_if = "Option::is_none")]
650  pub members: Option<Member>,
651  #[serde(skip_serializing_if = "Option::is_none")]
652  #[serde(rename = "exclusiveGroup")]
653  pub exclusive_group: Option<String>,
654}
655
656#[derive(Debug, Serialize, Deserialize, Default, Clone)]
657pub struct Member {
658  #[serde(skip_serializing_if = "Option::is_none")]
659  pub ids: Option<Vec<String>>,
660}
661#[derive(Debug, Serialize, Deserialize, Default, Clone)]
662pub struct XnameId {
663  #[serde(skip_serializing_if = "Option::is_none")]
664  pub id: Option<String>,
665}
666
667impl Group {
668  /// Constructor
669  pub fn new(
670    label: &str,
671    description: Option<String>,
672    member_vec_opt: Option<Vec<String>>,
673    tag_vec_opt: Option<Vec<String>>,
674    exclusive_opt: Option<String>,
675  ) -> Self {
676    let members_opt = if let Some(member_vec) = member_vec_opt {
677      Some(Member {
678        ids: Some(member_vec),
679      })
680    } else {
681      None
682    };
683
684    let group = Self {
685      label: label.to_string(),
686      description,
687      tags: tag_vec_opt,
688      members: members_opt,
689      exclusive_group: exclusive_opt,
690    };
691
692    group
693  }
694
695  /// Get group members
696  pub fn get_members(&self) -> Vec<String> {
697    self
698      .members
699      .clone()
700      .map(|member| member.ids.unwrap_or_default())
701      .unwrap_or_default()
702  }
703}
704
705#[derive(Debug, Serialize, Deserialize, Clone)]
706pub struct NodeMetadataArray {
707  #[serde(skip_serializing_if = "Option::is_none")]
708  #[serde(rename = "Components")]
709  pub components: Option<Vec<Component>>,
710}
711
712#[derive(Debug, Serialize, Deserialize, Clone)]
713pub struct Component {
714  #[serde(skip_serializing_if = "Option::is_none")]
715  #[serde(rename = "ID")]
716  pub id: Option<String>,
717  #[serde(skip_serializing_if = "Option::is_none")]
718  #[serde(rename = "Type")]
719  pub r#type: Option<String>,
720  #[serde(skip_serializing_if = "Option::is_none")]
721  #[serde(rename = "State")]
722  pub state: Option<String>,
723  #[serde(skip_serializing_if = "Option::is_none")]
724  #[serde(rename = "Flag")]
725  pub flag: Option<String>,
726  #[serde(skip_serializing_if = "Option::is_none")]
727  #[serde(rename = "Enabled")]
728  pub enabled: Option<bool>,
729  #[serde(skip_serializing_if = "Option::is_none")]
730  #[serde(rename = "SoftwareStatus")]
731  pub software_status: Option<String>,
732  #[serde(skip_serializing_if = "Option::is_none")]
733  #[serde(rename = "Role")]
734  pub role: Option<String>,
735  #[serde(skip_serializing_if = "Option::is_none")]
736  #[serde(rename = "SubRole")]
737  pub sub_role: Option<String>,
738  #[serde(skip_serializing_if = "Option::is_none")]
739  #[serde(rename = "NID")]
740  pub nid: Option<usize>,
741  #[serde(skip_serializing_if = "Option::is_none")]
742  #[serde(rename = "Subtype")]
743  pub subtype: Option<String>,
744  #[serde(skip_serializing_if = "Option::is_none")]
745  #[serde(rename = "NetType")]
746  pub net_type: Option<String>,
747  #[serde(skip_serializing_if = "Option::is_none")]
748  #[serde(rename = "Arch")]
749  pub arch: Option<String>,
750  #[serde(skip_serializing_if = "Option::is_none")]
751  #[serde(rename = "Class")]
752  pub class: Option<String>,
753  #[serde(skip_serializing_if = "Option::is_none")]
754  #[serde(rename = "ReservationDisabled")]
755  pub reservation_disabled: Option<bool>,
756  #[serde(skip_serializing_if = "Option::is_none")]
757  #[serde(rename = "Locked")]
758  pub locked: Option<bool>,
759}
760
761#[derive(Debug, Serialize, Deserialize, Clone)]
762pub struct ComponentArrayPostQuery {
763  #[serde(skip_serializing_if = "Option::is_none")]
764  #[serde(rename = "ComponentIDs")]
765  pub component_ids: Option<Vec<String>>,
766  #[serde(skip_serializing_if = "Option::is_none")]
767  pub partition: Option<String>,
768  #[serde(skip_serializing_if = "Option::is_none")]
769  pub group: Option<String>,
770  #[serde(skip_serializing_if = "Option::is_none")]
771  #[serde(rename = "stateonly")]
772  pub state_only: Option<bool>,
773  #[serde(skip_serializing_if = "Option::is_none")]
774  #[serde(rename = "flagonly")]
775  pub falg_only: Option<bool>,
776  #[serde(skip_serializing_if = "Option::is_none")]
777  #[serde(rename = "roleonly")]
778  pub role_only: Option<bool>,
779  #[serde(skip_serializing_if = "Option::is_none")]
780  #[serde(rename = "nidonly")]
781  pub nid_only: Option<bool>,
782  #[serde(skip_serializing_if = "Option::is_none")]
783  pub r#type: Option<String>,
784  #[serde(skip_serializing_if = "Option::is_none")]
785  pub state: Option<String>,
786  #[serde(skip_serializing_if = "Option::is_none")]
787  pub flag: Option<String>,
788  #[serde(skip_serializing_if = "Option::is_none")]
789  pub enabled: Option<String>,
790  #[serde(skip_serializing_if = "Option::is_none")]
791  #[serde(rename = "softwarestatus")]
792  pub software_status: Option<String>,
793  #[serde(skip_serializing_if = "Option::is_none")]
794  pub role: Option<String>,
795  #[serde(skip_serializing_if = "Option::is_none")]
796  pub subrole: Option<String>,
797  #[serde(skip_serializing_if = "Option::is_none")]
798  pub subtype: Option<String>,
799  #[serde(skip_serializing_if = "Option::is_none")]
800  arch: Option<String>,
801  #[serde(skip_serializing_if = "Option::is_none")]
802  pub class: Option<String>,
803  #[serde(skip_serializing_if = "Option::is_none")]
804  pub nid: Option<String>,
805  #[serde(skip_serializing_if = "Option::is_none")]
806  pub nid_start: Option<String>,
807  #[serde(skip_serializing_if = "Option::is_none")]
808  pub nid_end: Option<String>,
809}
810
811#[derive(Debug, Serialize, Deserialize, Clone)]
812pub struct ComponentArrayPostByNidQuery {
813  #[serde(rename = "NIDRanges")]
814  pub nid_ranges: Vec<String>,
815  #[serde(skip_serializing_if = "Option::is_none")]
816  pub partition: Option<String>,
817  #[serde(skip_serializing_if = "Option::is_none")]
818  #[serde(rename = "stateonly")]
819  pub state_only: Option<bool>,
820  #[serde(skip_serializing_if = "Option::is_none")]
821  #[serde(rename = "flagonly")]
822  pub falg_only: Option<bool>,
823  #[serde(skip_serializing_if = "Option::is_none")]
824  #[serde(rename = "roleonly")]
825  pub role_only: Option<bool>,
826  #[serde(skip_serializing_if = "Option::is_none")]
827  #[serde(rename = "nidonly")]
828  pub nid_only: Option<bool>,
829}
830
831#[derive(Debug, Serialize, Deserialize, Clone)]
832pub struct ComponentArrayPostArray {
833  #[serde(rename = "Components")]
834  pub components: Vec<ComponentCreate>,
835  #[serde(skip_serializing_if = "Option::is_none")]
836  #[serde(rename = "Force")]
837  pub force: Option<bool>,
838}
839
840#[derive(Debug, Serialize, Deserialize, Clone)]
841pub struct ComponentCreate {
842  #[serde(rename = "ID")]
843  pub id: String,
844  #[serde(rename = "State")]
845  pub state: String,
846  #[serde(skip_serializing_if = "Option::is_none")]
847  #[serde(rename = "Flag")]
848  pub flag: Option<String>,
849  #[serde(skip_serializing_if = "Option::is_none")]
850  #[serde(rename = "Enabled")]
851  pub enabled: Option<bool>,
852  #[serde(skip_serializing_if = "Option::is_none")]
853  #[serde(rename = "SoftwareStatus")]
854  pub software_status: Option<String>,
855  #[serde(skip_serializing_if = "Option::is_none")]
856  #[serde(rename = "Role")]
857  pub role: Option<String>,
858  #[serde(skip_serializing_if = "Option::is_none")]
859  #[serde(rename = "SubRole")]
860  pub sub_role: Option<String>,
861  #[serde(skip_serializing_if = "Option::is_none")]
862  #[serde(rename = "NID")]
863  pub nid: Option<usize>,
864  #[serde(skip_serializing_if = "Option::is_none")]
865  #[serde(rename = "Subtype")]
866  pub subtype: Option<String>,
867  #[serde(skip_serializing_if = "Option::is_none")]
868  #[serde(rename = "NetType")]
869  pub net_type: Option<String>,
870  #[serde(skip_serializing_if = "Option::is_none")]
871  #[serde(rename = "Arch")]
872  pub arch: Option<String>,
873  #[serde(skip_serializing_if = "Option::is_none")]
874  #[serde(rename = "Class")]
875  pub class: Option<String>,
876}
877
878#[derive(Debug, Serialize, Deserialize, Clone)]
879pub struct ComponentPut {
880  pub component: ComponentCreate,
881  #[serde(skip_serializing_if = "Option::is_none")]
882  #[serde(rename = "Force")]
883  pub force: Option<bool>,
884}
885
886#[derive(Debug, Serialize, Deserialize)]
887pub enum ComponentType {
888  CDU,
889  CabinetCDU,
890  CabinetPDU,
891  CabinetPDUOutlet,
892  CabinetPDUPowerConnector,
893  CabinetPDUController,
894  r#Cabinet,
895  Chassis,
896  ChassisBMC,
897  CMMRectifier,
898  CMMFpga,
899  CEC,
900  ComputeModule,
901  RouterModule,
902  NodeBMC,
903  NodeEnclosure,
904  NodeEnclosurePowerSupply,
905  HSNBoard,
906  Node,
907  Processor,
908  Drive,
909  StorageGroup,
910  NodeNIC,
911  Memory,
912  NodeAccel,
913  NodeAccelRiser,
914  NodeFpga,
915  HSNAsic,
916  RouterFpga,
917  RouterBMC,
918  HSNLink,
919  HSNConnector,
920  INVALID,
921}
922
923#[derive(Debug, Serialize, Deserialize, Clone)]
924pub struct ProcessorId {
925  #[serde(rename = "EffectiveFamily")]
926  #[serde(skip_serializing_if = "Option::is_none")]
927  pub effective_family: Option<String>,
928  #[serde(rename = "EffectiveModel")]
929  #[serde(skip_serializing_if = "Option::is_none")]
930  pub efffective_model: Option<String>,
931  #[serde(rename = "IdentificationRegisters")]
932  #[serde(skip_serializing_if = "Option::is_none")]
933  pub identification_registers: Option<String>,
934  #[serde(rename = "MicrocodeInfo")]
935  #[serde(skip_serializing_if = "Option::is_none")]
936  pub microcode_info: Option<String>,
937  #[serde(rename = "Step")]
938  #[serde(skip_serializing_if = "Option::is_none")]
939  pub step: Option<String>,
940  #[serde(rename = "VendorId")]
941  #[serde(skip_serializing_if = "Option::is_none")]
942  pub vendor_id: Option<String>,
943}
944
945#[derive(Debug, Serialize, Deserialize, Clone)]
946pub struct HWInvByFRUProcessor {
947  #[serde(rename = "FRUID")]
948  #[serde(skip_serializing_if = "Option::is_none")]
949  pub fru_id: Option<String>,
950  #[serde(rename = "Type")]
951  #[serde(skip_serializing_if = "Option::is_none")]
952  pub r#type: Option<String>,
953  #[serde(rename = "FRUSubType")]
954  #[serde(skip_serializing_if = "Option::is_none")]
955  pub fru_sub_type: Option<String>,
956  #[serde(rename = "HWInventoryByFRUType")]
957  pub hw_inventory_by_fru_type: String,
958  #[serde(rename = "ProcessorFRUInfo")]
959  pub processor_fru_info: RedfishProcessorFRUInfo,
960}
961
962#[derive(Debug, Serialize, Deserialize, Clone)]
963pub struct HWInvByFRUMemory {
964  #[serde(rename = "FRUID")]
965  #[serde(skip_serializing_if = "Option::is_none")]
966  pub fru_id: Option<String>,
967  #[serde(rename = "Type")]
968  #[serde(skip_serializing_if = "Option::is_none")]
969  pub r#type: Option<String>,
970  #[serde(rename = "FRUSubType")]
971  #[serde(skip_serializing_if = "Option::is_none")]
972  pub fru_sub_type: Option<String>,
973  #[serde(rename = "HWInventoryByFRUType")]
974  pub hw_inventory_by_fru_type: String,
975  #[serde(rename = "MemoryFRUInfo")]
976  pub memory_fru_info: RedfishMemoryFRUInfo,
977}
978
979#[derive(Debug, Serialize, Deserialize, Clone)]
980pub struct HWInvByFRUHSNNIC {
981  #[serde(rename = "FRUID")]
982  #[serde(skip_serializing_if = "Option::is_none")]
983  pub fru_id: Option<String>,
984  #[serde(rename = "Type")]
985  #[serde(skip_serializing_if = "Option::is_none")]
986  pub r#type: Option<String>,
987  #[serde(rename = "FRUSubType")]
988  #[serde(skip_serializing_if = "Option::is_none")]
989  pub fru_sub_type: Option<String>,
990  #[serde(rename = "HWInventoryByFRUType")]
991  pub hw_inventory_by_fru_type: String,
992  #[serde(rename = "HSNNICFRUInfo")]
993  pub hsn_nic_fru_info: HSNNICFRUInfo,
994}
995
996#[derive(Debug, Serialize, Deserialize, Clone)]
997pub struct HWInvByFRUNodeAccel {
998  #[serde(rename = "FRUID")]
999  #[serde(skip_serializing_if = "Option::is_none")]
1000  pub fru_id: Option<String>,
1001  #[serde(rename = "Type")]
1002  #[serde(skip_serializing_if = "Option::is_none")]
1003  pub r#type: Option<String>,
1004  #[serde(rename = "FRUSubType")]
1005  #[serde(skip_serializing_if = "Option::is_none")]
1006  pub fru_sub_type: Option<String>,
1007  #[serde(rename = "HWInventoryByFRUType")]
1008  pub hw_inventory_by_fru_type: String,
1009  #[serde(rename = "NodeAccelFRUInfo")]
1010  pub node_accel_fru_info: RedfishProcessorFRUInfo, // NOTE: yes, sounds weird FRU for node accelerator uses FRU for processor... but that is
1011                                                    // what the API docs says...
1012}
1013
1014#[derive(Debug, Serialize, Deserialize, Clone)]
1015pub struct RedfishProcessorFRUInfo {
1016  #[serde(rename = "InstructionSet")]
1017  #[serde(skip_serializing_if = "Option::is_none")]
1018  pub instruction_set: Option<String>,
1019  #[serde(rename = "Manufacturer")]
1020  #[serde(skip_serializing_if = "Option::is_none")]
1021  pub manufacturer: Option<String>,
1022  #[serde(rename = "MaxSpeedMHz")]
1023  #[serde(skip_serializing_if = "Option::is_none")]
1024  pub max_speed_mhz: Option<usize>,
1025  #[serde(rename = "Model")]
1026  #[serde(skip_serializing_if = "Option::is_none")]
1027  pub model: Option<String>,
1028  #[serde(rename = "ProcessorArchitecture")]
1029  #[serde(skip_serializing_if = "Option::is_none")]
1030  pub processor_architecture: Option<String>,
1031  #[serde(rename = "ProcessorId")]
1032  #[serde(skip_serializing_if = "Option::is_none")]
1033  pub processor_id: Option<ProcessorId>,
1034  #[serde(rename = "ProcessorType")]
1035  #[serde(skip_serializing_if = "Option::is_none")]
1036  pub processor_type: Option<String>,
1037  #[serde(rename = "TotalCores")]
1038  #[serde(skip_serializing_if = "Option::is_none")]
1039  pub total_cores: Option<usize>,
1040  #[serde(rename = "TotalThreads")]
1041  #[serde(skip_serializing_if = "Option::is_none")]
1042  pub total_threads: Option<usize>,
1043}
1044
1045#[derive(Debug, Serialize, Deserialize, Clone)]
1046pub struct RedfishMemoryFRUInfo {
1047  #[serde(rename = "BaseModuleType")]
1048  #[serde(skip_serializing_if = "Option::is_none")]
1049  pub base_module_type: Option<String>,
1050  #[serde(rename = "BusWidthBits")]
1051  #[serde(skip_serializing_if = "Option::is_none")]
1052  pub bus_width_bits: Option<usize>,
1053  #[serde(rename = "CapacityMiB")]
1054  #[serde(skip_serializing_if = "Option::is_none")]
1055  pub capacity_mib: Option<usize>,
1056  #[serde(rename = "DataWidthBits")]
1057  #[serde(skip_serializing_if = "Option::is_none")]
1058  pub data_width_bits: Option<usize>,
1059  #[serde(rename = "ErrorCorrection")]
1060  #[serde(skip_serializing_if = "Option::is_none")]
1061  pub error_correction: Option<String>,
1062  #[serde(rename = "Manufacturer")]
1063  #[serde(skip_serializing_if = "Option::is_none")]
1064  pub manufacturer: Option<String>,
1065  #[serde(rename = "MemoryType")]
1066  #[serde(skip_serializing_if = "Option::is_none")]
1067  pub memory_type: Option<String>,
1068  #[serde(rename = "MemoryDeviceType")]
1069  #[serde(skip_serializing_if = "Option::is_none")]
1070  pub memory_device_type: Option<String>,
1071  #[serde(rename = "OperatingSpeedMhz")]
1072  #[serde(skip_serializing_if = "Option::is_none")]
1073  pub operating_speed_mhz: Option<usize>,
1074  #[serde(rename = "PartNumber")]
1075  #[serde(skip_serializing_if = "Option::is_none")]
1076  pub part_number: Option<String>,
1077  #[serde(rename = "RankCount")]
1078  #[serde(skip_serializing_if = "Option::is_none")]
1079  pub rank_count: Option<usize>,
1080  #[serde(rename = "SerialNumber")]
1081  #[serde(skip_serializing_if = "Option::is_none")]
1082  pub serial_number: Option<String>,
1083}
1084
1085#[derive(Debug, Serialize, Deserialize, Clone)]
1086pub struct HWInventoryByFRU {
1087  #[serde(rename = "FRUID")]
1088  #[serde(skip_serializing_if = "Option::is_none")]
1089  pub fru_id: Option<String>,
1090  #[serde(rename = "Type")]
1091  #[serde(skip_serializing_if = "Option::is_none")]
1092  pub r#type: Option<String>,
1093  #[serde(rename = "FRUSubType")]
1094  #[serde(skip_serializing_if = "Option::is_none")]
1095  pub fru_sub_type: Option<String>,
1096  #[serde(rename = "HWInventoryByFRUType")]
1097  pub hw_inventory_by_fru_type: String,
1098}
1099
1100#[derive(Debug, Serialize, Deserialize, Clone)]
1101pub struct RedfishChassisLocationInfo {
1102  #[serde(rename = "Id")]
1103  #[serde(skip_serializing_if = "Option::is_none")]
1104  pub id: Option<String>,
1105  #[serde(rename = "Name")]
1106  #[serde(skip_serializing_if = "Option::is_none")]
1107  pub name: Option<String>,
1108  #[serde(rename = "Description")]
1109  #[serde(skip_serializing_if = "Option::is_none")]
1110  pub description: Option<String>,
1111  #[serde(rename = "Hostname")]
1112  #[serde(skip_serializing_if = "Option::is_none")]
1113  pub hostname: Option<String>,
1114}
1115
1116#[derive(Debug, Serialize, Deserialize, Clone)]
1117pub struct HWInvByLocChassis {
1118  #[serde(rename = "ID")]
1119  pub id: String,
1120  #[serde(rename = "Type")]
1121  #[serde(skip_serializing_if = "Option::is_none")]
1122  pub r#type: Option<String>,
1123  #[serde(rename = "Ordinal")]
1124  #[serde(skip_serializing_if = "Option::is_none")]
1125  pub ordinal: Option<u32>,
1126  #[serde(rename = "Status")]
1127  #[serde(skip_serializing_if = "Option::is_none")]
1128  pub status: Option<String>,
1129  #[serde(rename = "HWInventoryByLocationType")]
1130  pub hw_inventory_by_location_type: String,
1131  #[serde(rename = "PopulatedFRU")]
1132  #[serde(skip_serializing_if = "Option::is_none")]
1133  pub populated_fru: Option<HWInventoryByFRU>,
1134  #[serde(rename = "ChassisLocatinInfo")]
1135  #[serde(skip_serializing_if = "Option::is_none")]
1136  pub chassis_location_info: Option<RedfishChassisLocationInfo>,
1137  #[serde(rename = "ComputeModules")]
1138  #[serde(skip_serializing_if = "Option::is_none")]
1139  pub compute_modules: Option<HWInvByLocComputeModule>,
1140  #[serde(rename = "RouterModules")]
1141  #[serde(skip_serializing_if = "Option::is_none")]
1142  pub router_modules: Option<HWInvByLocRouterModule>,
1143}
1144
1145#[derive(Debug, Serialize, Deserialize, Clone)]
1146pub struct HWInvByLocNodeEnclosure {
1147  #[serde(rename = "ID")]
1148  pub id: String,
1149  #[serde(rename = "Type")]
1150  #[serde(skip_serializing_if = "Option::is_none")]
1151  pub r#type: Option<String>,
1152  #[serde(rename = "Ordinal")]
1153  #[serde(skip_serializing_if = "Option::is_none")]
1154  pub ordinal: Option<u32>,
1155  #[serde(rename = "Status")]
1156  #[serde(skip_serializing_if = "Option::is_none")]
1157  pub status: Option<String>,
1158  #[serde(rename = "HWInventoryByLocationType")]
1159  pub hw_inventory_by_location_type: String,
1160  #[serde(rename = "PopulatedFRU")]
1161  #[serde(skip_serializing_if = "Option::is_none")]
1162  pub populated_fru: Option<HWInventoryByFRU>,
1163  #[serde(rename = "NodeEnclosureLocationInfo")]
1164  #[serde(skip_serializing_if = "Option::is_none")]
1165  pub node_enclosure_location_info: Option<RedfishChassisLocationInfo>,
1166}
1167
1168#[derive(Debug, Serialize, Deserialize, Clone)]
1169pub struct HWInvByLocComputeModule {
1170  #[serde(rename = "ID")]
1171  pub id: String,
1172  #[serde(rename = "Type")]
1173  #[serde(skip_serializing_if = "Option::is_none")]
1174  pub r#type: Option<String>,
1175  #[serde(rename = "Ordinal")]
1176  #[serde(skip_serializing_if = "Option::is_none")]
1177  pub ordinal: Option<u32>,
1178  #[serde(rename = "Status")]
1179  #[serde(skip_serializing_if = "Option::is_none")]
1180  pub status: Option<String>,
1181  #[serde(rename = "HWInventoryByLocationType")]
1182  pub hw_inventory_by_location_type: String,
1183  #[serde(rename = "PopulatedFRU")]
1184  #[serde(skip_serializing_if = "Option::is_none")]
1185  pub populated_fru: Option<HWInventoryByFRU>,
1186  #[serde(rename = "ComputeModuleLocationInfo")]
1187  #[serde(skip_serializing_if = "Option::is_none")]
1188  pub compute_module_location_info: Option<RedfishChassisLocationInfo>,
1189  #[serde(rename = "NodeEnclosures")]
1190  #[serde(skip_serializing_if = "Option::is_none")]
1191  pub node_enclosures: Option<HWInvByLocNodeEnclosure>,
1192}
1193
1194#[derive(Debug, Serialize, Deserialize, Clone)]
1195pub struct HWInvByLocHSNBoard {
1196  #[serde(rename = "ID")]
1197  pub id: String,
1198  #[serde(rename = "Type")]
1199  #[serde(skip_serializing_if = "Option::is_none")]
1200  pub r#type: Option<String>,
1201  #[serde(rename = "Ordinal")]
1202  #[serde(skip_serializing_if = "Option::is_none")]
1203  pub ordinal: Option<u32>,
1204  #[serde(rename = "Status")]
1205  #[serde(skip_serializing_if = "Option::is_none")]
1206  pub status: Option<String>,
1207  #[serde(rename = "HWInventoryByLocationType")]
1208  pub hw_inventory_by_location_type: String,
1209  #[serde(rename = "PopulatedFRU")]
1210  #[serde(skip_serializing_if = "Option::is_none")]
1211  pub populated_fru: Option<HWInventoryByFRU>,
1212  #[serde(rename = "HSNBoardLocationInfo")]
1213  #[serde(skip_serializing_if = "Option::is_none")]
1214  pub hsn_board_location_info: Option<RedfishChassisLocationInfo>,
1215}
1216
1217#[derive(Debug, Serialize, Deserialize, Clone)]
1218pub struct HWInvByLocRouterModule {
1219  #[serde(rename = "ID")]
1220  pub id: String,
1221  #[serde(rename = "Type")]
1222  #[serde(skip_serializing_if = "Option::is_none")]
1223  pub r#type: Option<String>,
1224  #[serde(rename = "Ordinal")]
1225  #[serde(skip_serializing_if = "Option::is_none")]
1226  pub ordinal: Option<u32>,
1227  #[serde(rename = "Status")]
1228  #[serde(skip_serializing_if = "Option::is_none")]
1229  pub status: Option<String>,
1230  #[serde(rename = "HWInventoryByLocationType")]
1231  pub hw_inventory_by_location_type: String,
1232  #[serde(rename = "PopulatedFRU")]
1233  #[serde(skip_serializing_if = "Option::is_none")]
1234  pub populated_fru: Option<HWInventoryByFRU>,
1235  #[serde(rename = "RouterModuleLocationInfo")]
1236  #[serde(skip_serializing_if = "Option::is_none")]
1237  pub router_module_location_info: Option<RedfishChassisLocationInfo>,
1238  pub hsn_boards: Option<HWInvByLocHSNBoard>,
1239}
1240
1241#[derive(Debug, Serialize, Deserialize, Clone)]
1242pub struct HWInvByLocCabinet {
1243  #[serde(rename = "ID")]
1244  pub id: String,
1245  #[serde(rename = "Type")]
1246  #[serde(skip_serializing_if = "Option::is_none")]
1247  pub r#type: Option<String>,
1248  #[serde(rename = "Ordinal")]
1249  #[serde(skip_serializing_if = "Option::is_none")]
1250  pub ordinal: Option<u32>,
1251  #[serde(rename = "Status")]
1252  #[serde(skip_serializing_if = "Option::is_none")]
1253  pub status: Option<String>,
1254  #[serde(rename = "HWInventoryByLocationType")]
1255  pub hw_inventory_by_location_type: String,
1256  #[serde(rename = "PopulatedFRU")]
1257  #[serde(skip_serializing_if = "Option::is_none")]
1258  pub populated_fru: Option<HWInventoryByFRU>,
1259  #[serde(rename = "CabinetLocationInfo")]
1260  #[serde(skip_serializing_if = "Option::is_none")]
1261  pub cabinet_location_info: Option<RedfishChassisLocationInfo>,
1262  #[serde(rename = "Chassis")]
1263  #[serde(skip_serializing_if = "Option::is_none")]
1264  pub chassis: Option<HWInvByLocChassis>,
1265}
1266
1267#[derive(Debug, Serialize, Deserialize, Clone)]
1268pub struct HWInvByLocMgmtSwitch {
1269  #[serde(rename = "ID")]
1270  pub id: String,
1271  #[serde(rename = "Type")]
1272  #[serde(skip_serializing_if = "Option::is_none")]
1273  pub r#type: Option<String>,
1274  #[serde(rename = "Ordinal")]
1275  #[serde(skip_serializing_if = "Option::is_none")]
1276  pub ordinal: Option<u32>,
1277  #[serde(rename = "Status")]
1278  #[serde(skip_serializing_if = "Option::is_none")]
1279  pub status: Option<String>,
1280  #[serde(rename = "HWInventoryByLocationType")]
1281  pub hw_inventory_by_location_type: String,
1282  #[serde(rename = "PopulatedFRU")]
1283  #[serde(skip_serializing_if = "Option::is_none")]
1284  pub populated_fru: Option<HWInventoryByFRU>,
1285  #[serde(rename = "MgmtSwitchLocationInfo")]
1286  #[serde(skip_serializing_if = "Option::is_none")]
1287  pub mgmt_switch_location_info: Option<RedfishChassisLocationInfo>,
1288}
1289
1290#[derive(Debug, Serialize, Deserialize, Clone)]
1291pub struct HWInvByLocMgmtHLSwitch {
1292  #[serde(rename = "ID")]
1293  pub id: String,
1294  #[serde(rename = "Type")]
1295  #[serde(skip_serializing_if = "Option::is_none")]
1296  pub r#type: Option<String>,
1297  #[serde(rename = "Ordinal")]
1298  #[serde(skip_serializing_if = "Option::is_none")]
1299  pub ordinal: Option<u32>,
1300  #[serde(rename = "Status")]
1301  #[serde(skip_serializing_if = "Option::is_none")]
1302  pub status: Option<String>,
1303  #[serde(rename = "HWInventoryByLocationType")]
1304  pub hw_inventory_by_location_type: String,
1305  #[serde(rename = "PopulatedFRU")]
1306  #[serde(skip_serializing_if = "Option::is_none")]
1307  pub populated_fru: Option<HWInventoryByFRU>,
1308  #[serde(rename = "MgmtHLSwitchLocationInfo")]
1309  #[serde(skip_serializing_if = "Option::is_none")]
1310  pub mgmt_hl_switch_location_info: Option<RedfishChassisLocationInfo>,
1311}
1312
1313#[derive(Debug, Serialize, Deserialize, Clone)]
1314pub struct HWInvByLocCDUMgmtSwitch {
1315  #[serde(rename = "ID")]
1316  pub id: String,
1317  #[serde(rename = "Type")]
1318  #[serde(skip_serializing_if = "Option::is_none")]
1319  pub r#type: Option<String>,
1320  #[serde(rename = "Ordinal")]
1321  #[serde(skip_serializing_if = "Option::is_none")]
1322  pub ordinal: Option<u32>,
1323  #[serde(rename = "Status")]
1324  #[serde(skip_serializing_if = "Option::is_none")]
1325  pub status: Option<String>,
1326  #[serde(rename = "HWInventoryByLocationType")]
1327  pub hw_inventory_by_location_type: String,
1328  #[serde(rename = "PopulatedFRU")]
1329  #[serde(skip_serializing_if = "Option::is_none")]
1330  pub populated_fru: Option<HWInventoryByFRU>,
1331  #[serde(rename = "CDUMgmtSwitchLocationInfo")]
1332  #[serde(skip_serializing_if = "Option::is_none")]
1333  pub cdu_mgmt_switch_location_info: Option<RedfishChassisLocationInfo>,
1334}
1335
1336#[derive(Debug, Serialize, Deserialize, Clone)]
1337pub struct ProcessorSummary {
1338  #[serde(rename = "Count")]
1339  #[serde(skip_serializing_if = "Option::is_none")]
1340  pub count: Option<u32>,
1341  #[serde(rename = "Model")]
1342  #[serde(skip_serializing_if = "Option::is_none")]
1343  pub model: Option<String>,
1344}
1345
1346#[derive(Debug, Serialize, Deserialize, Clone)]
1347pub struct MemorySummary {
1348  #[serde(rename = "TotalSystemMemoryGiB")]
1349  #[serde(skip_serializing_if = "Option::is_none")]
1350  pub total_system_memory_gib: Option<u32>,
1351}
1352
1353#[derive(Debug, Serialize, Deserialize, Clone)]
1354pub struct RedfishSystemLocationInfo {
1355  #[serde(rename = "Id")]
1356  #[serde(skip_serializing_if = "Option::is_none")]
1357  pub id: Option<String>,
1358  #[serde(rename = "Name")]
1359  #[serde(skip_serializing_if = "Option::is_none")]
1360  pub name: Option<String>,
1361  #[serde(rename = "Description")]
1362  #[serde(skip_serializing_if = "Option::is_none")]
1363  pub description: Option<String>,
1364  #[serde(rename = "Hostname")]
1365  #[serde(skip_serializing_if = "Option::is_none")]
1366  pub hostname: Option<String>,
1367  #[serde(rename = "ProcessorSummary")]
1368  #[serde(skip_serializing_if = "Option::is_none")]
1369  pub processor_summary: Option<ProcessorSummary>,
1370  #[serde(rename = "MemorySummary")]
1371  #[serde(skip_serializing_if = "Option::is_none")]
1372  pub memory_summary: Option<MemorySummary>,
1373}
1374
1375#[derive(Debug, Serialize, Deserialize, Clone)]
1376pub struct RedfishProcessorLocationInfo {
1377  #[serde(rename = "Id")]
1378  #[serde(skip_serializing_if = "Option::is_none")]
1379  pub id: Option<String>,
1380  #[serde(rename = "Name")]
1381  #[serde(skip_serializing_if = "Option::is_none")]
1382  pub name: Option<String>,
1383  #[serde(rename = "Description")]
1384  #[serde(skip_serializing_if = "Option::is_none")]
1385  pub description: Option<String>,
1386  #[serde(rename = "Socket")]
1387  #[serde(skip_serializing_if = "Option::is_none")]
1388  pub socket: Option<String>,
1389}
1390
1391#[derive(Debug, Serialize, Deserialize, Clone)]
1392pub struct HWInvByLocProcessor {
1393  #[serde(rename = "ID")]
1394  pub id: String,
1395  #[serde(rename = "Type")]
1396  #[serde(skip_serializing_if = "Option::is_none")]
1397  pub r#type: Option<String>,
1398  #[serde(rename = "Ordinal")]
1399  #[serde(skip_serializing_if = "Option::is_none")]
1400  pub ordinal: Option<u32>,
1401  #[serde(rename = "Status")]
1402  #[serde(skip_serializing_if = "Option::is_none")]
1403  pub status: Option<String>,
1404  #[serde(rename = "HWInventoryByLocationType")]
1405  pub hw_inventory_by_location_type: String,
1406  #[serde(rename = "PopulatedFRU")]
1407  #[serde(skip_serializing_if = "Option::is_none")]
1408  pub populated_fru: Option<HWInvByFRUProcessor>,
1409  #[serde(rename = "ProcessorLocationInfo")]
1410  pub processor_location_info: RedfishProcessorLocationInfo,
1411}
1412
1413#[derive(Debug, Serialize, Deserialize, Clone)]
1414pub struct HWInvByLocNodeAccel {
1415  #[serde(rename = "ID")]
1416  pub id: String,
1417  #[serde(rename = "Type")]
1418  #[serde(skip_serializing_if = "Option::is_none")]
1419  pub r#type: Option<String>,
1420  #[serde(rename = "Ordinal")]
1421  #[serde(skip_serializing_if = "Option::is_none")]
1422  pub ordinal: Option<u32>,
1423  #[serde(rename = "Status")]
1424  #[serde(skip_serializing_if = "Option::is_none")]
1425  pub status: Option<String>,
1426  #[serde(rename = "HWInventoryByLocationType")]
1427  pub hw_inventory_by_location_type: String,
1428  #[serde(rename = "PopulatedFRU")]
1429  #[serde(skip_serializing_if = "Option::is_none")]
1430  pub populated_fru: Option<HWInvByFRUNodeAccel>,
1431  #[serde(rename = "NodeAccelLocationInfo")]
1432  #[serde(skip_serializing_if = "Option::is_none")]
1433  pub node_accel_location_info: Option<RedfishProcessorLocationInfo>,
1434}
1435
1436#[derive(Debug, Serialize, Deserialize, Clone)]
1437pub struct RedfishDriveLocationInfo {
1438  #[serde(rename = "Id")]
1439  #[serde(skip_serializing_if = "Option::is_none")]
1440  pub id: Option<String>,
1441  #[serde(rename = "Name")]
1442  #[serde(skip_serializing_if = "Option::is_none")]
1443  pub name: Option<String>,
1444  #[serde(rename = "Description")]
1445  #[serde(skip_serializing_if = "Option::is_none")]
1446  pub description: Option<String>,
1447}
1448
1449#[derive(Debug, Serialize, Deserialize, Clone)]
1450pub struct HWInvByLocDrive {
1451  #[serde(rename = "ID")]
1452  pub id: String,
1453  #[serde(rename = "Type")]
1454  #[serde(skip_serializing_if = "Option::is_none")]
1455  pub r#type: Option<String>,
1456  #[serde(rename = "Ordinal")]
1457  #[serde(skip_serializing_if = "Option::is_none")]
1458  pub ordinal: Option<u32>,
1459  #[serde(rename = "Status")]
1460  #[serde(skip_serializing_if = "Option::is_none")]
1461  pub status: Option<String>,
1462  #[serde(rename = "HWInventoryByLocationType")]
1463  pub hw_inventory_by_location_type: String,
1464  #[serde(rename = "PopulatedFRU")]
1465  #[serde(skip_serializing_if = "Option::is_none")]
1466  pub populated_fru: Option<HWInventoryByFRU>,
1467  #[serde(rename = "DriveLocationInfo")]
1468  #[serde(skip_serializing_if = "Option::is_none")]
1469  pub drive_location_info: Option<RedfishDriveLocationInfo>,
1470}
1471
1472#[derive(Debug, Serialize, Deserialize, Clone)]
1473pub struct MemoryLocation {
1474  #[serde(rename = "Socket")]
1475  #[serde(skip_serializing_if = "Option::is_none")]
1476  pub socket: Option<u32>,
1477  #[serde(rename = "MemoryController")]
1478  #[serde(skip_serializing_if = "Option::is_none")]
1479  pub memory_controller: Option<u32>,
1480  #[serde(rename = "Channel")]
1481  #[serde(skip_serializing_if = "Option::is_none")]
1482  pub channel: Option<u32>,
1483  #[serde(rename = "Slot")]
1484  #[serde(skip_serializing_if = "Option::is_none")]
1485  pub slot: Option<u32>,
1486}
1487
1488#[derive(Debug, Serialize, Deserialize, Clone)]
1489pub struct RedfishMemoryLocationInfo {
1490  #[serde(rename = "Id")]
1491  #[serde(skip_serializing_if = "Option::is_none")]
1492  pub id: Option<String>,
1493  #[serde(rename = "Name")]
1494  #[serde(skip_serializing_if = "Option::is_none")]
1495  pub name: Option<String>,
1496  #[serde(rename = "Description")]
1497  #[serde(skip_serializing_if = "Option::is_none")]
1498  pub description: Option<String>,
1499  #[serde(rename = "MemoryLocation")]
1500  #[serde(skip_serializing_if = "Option::is_none")]
1501  pub memory_location: Option<MemoryLocation>,
1502}
1503
1504#[derive(Debug, Serialize, Deserialize, Clone)]
1505pub struct HWInvByLocMemory {
1506  #[serde(rename = "ID")]
1507  pub id: String,
1508  #[serde(rename = "Type")]
1509  #[serde(skip_serializing_if = "Option::is_none")]
1510  pub r#type: Option<String>,
1511  #[serde(rename = "Ordinal")]
1512  #[serde(skip_serializing_if = "Option::is_none")]
1513  pub ordinal: Option<u32>,
1514  #[serde(rename = "Status")]
1515  #[serde(skip_serializing_if = "Option::is_none")]
1516  pub status: Option<String>,
1517  #[serde(rename = "HWInventoryByLocationType")]
1518  pub hw_inventory_by_location_type: String,
1519  #[serde(rename = "PopulatedFRU")]
1520  #[serde(skip_serializing_if = "Option::is_none")]
1521  pub populated_fru: Option<HWInvByFRUMemory>,
1522  #[serde(rename = "MemoryLocationInfo")]
1523  pub memory_location_info: RedfishMemoryLocationInfo,
1524}
1525
1526#[derive(Debug, Serialize, Deserialize, Clone)]
1527pub struct RedfishNodeAccelRiserLocationInfo {
1528  #[serde(rename = "Name")]
1529  #[serde(skip_serializing_if = "Option::is_none")]
1530  pub name: Option<String>,
1531  #[serde(rename = "Description")]
1532  #[serde(skip_serializing_if = "Option::is_none")]
1533  pub description: Option<String>,
1534}
1535
1536#[derive(Debug, Serialize, Deserialize, Clone)]
1537pub struct HWInvByLocNodeAccelRiser {
1538  #[serde(rename = "ID")]
1539  pub id: String,
1540  #[serde(rename = "Type")]
1541  #[serde(skip_serializing_if = "Option::is_none")]
1542  pub r#type: Option<String>,
1543  #[serde(rename = "Ordinal")]
1544  #[serde(skip_serializing_if = "Option::is_none")]
1545  pub ordinal: Option<u32>,
1546  #[serde(rename = "Status")]
1547  #[serde(skip_serializing_if = "Option::is_none")]
1548  pub status: Option<String>,
1549  #[serde(rename = "HWInventoryByLocationType")]
1550  pub hw_inventory_by_location_type: String,
1551  #[serde(rename = "PopulatedFRU")]
1552  #[serde(skip_serializing_if = "Option::is_none")]
1553  pub populated_fru: Option<HWInventoryByFRU>,
1554  #[serde(rename = "NodeAccelRiserLocationInfo")]
1555  #[serde(skip_serializing_if = "Option::is_none")]
1556  pub node_accel_riser_location_info: Option<RedfishNodeAccelRiserLocationInfo>,
1557}
1558
1559#[derive(Debug, Serialize, Deserialize, Clone)]
1560pub struct HSNNICLocationInfo {
1561  #[serde(rename = "Id")]
1562  #[serde(skip_serializing_if = "Option::is_none")]
1563  pub id: Option<String>,
1564  #[serde(rename = "Name")]
1565  #[serde(skip_serializing_if = "Option::is_none")]
1566  pub name: Option<String>,
1567  #[serde(rename = "Description")]
1568  #[serde(skip_serializing_if = "Option::is_none")]
1569  pub description: Option<String>,
1570}
1571
1572#[derive(Debug, Serialize, Deserialize, Clone)]
1573pub struct HWInvByLocHSNNIC {
1574  #[serde(rename = "ID")]
1575  pub id: String,
1576  #[serde(rename = "Type")]
1577  #[serde(skip_serializing_if = "Option::is_none")]
1578  pub r#type: Option<String>,
1579  #[serde(rename = "Ordinal")]
1580  #[serde(skip_serializing_if = "Option::is_none")]
1581  pub ordinal: Option<u32>,
1582  #[serde(rename = "Status")]
1583  #[serde(skip_serializing_if = "Option::is_none")]
1584  pub status: Option<String>,
1585  #[serde(rename = "HWInventoryByLocationType")]
1586  pub hw_inventory_by_location_type: String,
1587  #[serde(rename = "PopulatedFRU")]
1588  #[serde(skip_serializing_if = "Option::is_none")]
1589  pub populated_fru: Option<HWInvByFRUHSNNIC>,
1590  /* #[serde(rename = "NodeHsnNicLocationInfo")]
1591  pub node_hsn_nic_location_info: HSNNICLocationInfo, */
1592  #[serde(rename = "HSNNICLocationInfo")]
1593  pub hsn_nic_location_info: HSNNICLocationInfo,
1594}
1595
1596#[derive(Debug, Serialize, Deserialize, Clone)]
1597pub struct RedfishSystemFRUInfo {
1598  #[serde(rename = "AssetTag")]
1599  #[serde(skip_serializing_if = "Option::is_none")]
1600  pub asset_tag: Option<String>,
1601  #[serde(rename = "BiosVersion")]
1602  #[serde(skip_serializing_if = "Option::is_none")]
1603  pub bios_version: Option<String>,
1604  #[serde(rename = "Model")]
1605  #[serde(skip_serializing_if = "Option::is_none")]
1606  pub model: Option<String>,
1607  #[serde(rename = "Manufacturer")]
1608  #[serde(skip_serializing_if = "Option::is_none")]
1609  pub manufacturer: Option<String>,
1610  #[serde(rename = "PartNumber")]
1611  #[serde(skip_serializing_if = "Option::is_none")]
1612  pub part_number: Option<String>,
1613  #[serde(rename = "SerialNumber")]
1614  #[serde(skip_serializing_if = "Option::is_none")]
1615  pub serial_number: Option<String>,
1616  #[serde(rename = "SKU")]
1617  #[serde(skip_serializing_if = "Option::is_none")]
1618  pub sku: Option<String>,
1619  #[serde(rename = "SystemType")]
1620  #[serde(skip_serializing_if = "Option::is_none")]
1621  pub system_type: Option<String>,
1622  #[serde(rename = "UUID")]
1623  #[serde(skip_serializing_if = "Option::is_none")]
1624  pub uuid: Option<String>,
1625}
1626
1627#[derive(Debug, Serialize, Deserialize, Clone)]
1628pub struct HWInvByFRUNode {
1629  #[serde(rename = "FRUID")]
1630  #[serde(skip_serializing_if = "Option::is_none")]
1631  pub fru_id: Option<String>,
1632  #[serde(rename = "Type")]
1633  #[serde(skip_serializing_if = "Option::is_none")]
1634  pub r#type: Option<String>,
1635  #[serde(rename = "FRUSubType")]
1636  #[serde(skip_serializing_if = "Option::is_none")]
1637  pub fru_sub_type: Option<String>,
1638  #[serde(rename = "HWInventoryByFRUType")]
1639  pub hw_inventory_by_fru_type: String,
1640  #[serde(rename = "NodeFRUInfo")]
1641  pub node_fru_info: RedfishSystemFRUInfo,
1642}
1643
1644#[derive(Debug, Serialize, Deserialize, Clone)]
1645pub struct HSNNICFRUInfo {
1646  #[serde(rename = "Manufacturer")]
1647  #[serde(skip_serializing_if = "Option::is_none")]
1648  pub manufacturer: Option<String>,
1649  #[serde(rename = "Model")]
1650  #[serde(skip_serializing_if = "Option::is_none")]
1651  pub model: Option<String>,
1652  #[serde(rename = "PartNumber")]
1653  #[serde(skip_serializing_if = "Option::is_none")]
1654  pub part_number: Option<String>,
1655  #[serde(rename = "SKU")]
1656  #[serde(skip_serializing_if = "Option::is_none")]
1657  pub sku: Option<String>,
1658  #[serde(rename = "SerialNumber")]
1659  #[serde(skip_serializing_if = "Option::is_none")]
1660  pub serial_number: Option<String>,
1661}
1662
1663#[derive(Debug, Serialize, Deserialize, Clone)]
1664pub struct HWInvByLocNode {
1665  #[serde(rename = "ID")]
1666  pub id: String,
1667  #[serde(rename = "Type")]
1668  #[serde(skip_serializing_if = "Option::is_none")]
1669  pub r#type: Option<String>,
1670  #[serde(rename = "Ordinal")]
1671  #[serde(skip_serializing_if = "Option::is_none")]
1672  pub ordinal: Option<u32>,
1673  #[serde(rename = "Status")]
1674  #[serde(skip_serializing_if = "Option::is_none")]
1675  pub status: Option<String>,
1676  #[serde(rename = "HWInventoryByLocationType")]
1677  pub hw_inventory_by_location_type: String,
1678  #[serde(rename = "PopulatedFRU")]
1679  #[serde(skip_serializing_if = "Option::is_none")]
1680  pub populated_fru: Option<HWInvByFRUNode>,
1681  #[serde(rename = "NodeLocationInfo")]
1682  #[serde(skip_serializing_if = "Option::is_none")]
1683  pub node_location_info: Option<RedfishSystemLocationInfo>,
1684  #[serde(rename = "Processors")]
1685  #[serde(skip_serializing_if = "Option::is_none")]
1686  pub processors: Option<Vec<HWInvByLocProcessor>>,
1687  #[serde(rename = "NodeAccels")]
1688  #[serde(skip_serializing_if = "Option::is_none")]
1689  pub node_accels: Option<Vec<HWInvByLocNodeAccel>>,
1690  #[serde(rename = "Dives")]
1691  #[serde(skip_serializing_if = "Option::is_none")]
1692  pub drives: Option<Vec<HWInvByLocDrive>>,
1693  #[serde(rename = "Memory")]
1694  #[serde(skip_serializing_if = "Option::is_none")]
1695  pub memory: Option<Vec<HWInvByLocMemory>>,
1696  #[serde(rename = "NodeAccelRisers")]
1697  #[serde(skip_serializing_if = "Option::is_none")]
1698  pub node_accel_risers: Option<Vec<HWInvByLocNodeAccelRiser>>,
1699  #[serde(rename = "NodeHsnNICs")]
1700  #[serde(skip_serializing_if = "Option::is_none")]
1701  pub node_hsn_nics: Option<Vec<HWInvByLocHSNNIC>>,
1702}
1703
1704#[derive(Debug, Serialize, Deserialize, Clone)]
1705pub struct RedfishPDULocationInfo {
1706  #[serde(rename = "Id")]
1707  #[serde(skip_serializing_if = "Option::is_none")]
1708  pub id: Option<String>,
1709  #[serde(rename = "Name")]
1710  #[serde(skip_serializing_if = "Option::is_none")]
1711  pub name: Option<String>,
1712  #[serde(rename = "Description")]
1713  #[serde(skip_serializing_if = "Option::is_none")]
1714  pub description: Option<String>,
1715  #[serde(rename = "UUID")]
1716  #[serde(skip_serializing_if = "Option::is_none")]
1717  pub uuid: Option<String>,
1718}
1719
1720#[derive(Debug, Serialize, Deserialize, Clone)]
1721pub struct RedfishOutletLocationInfo {
1722  #[serde(rename = "Id")]
1723  #[serde(skip_serializing_if = "Option::is_none")]
1724  pub id: Option<String>,
1725  #[serde(rename = "Name")]
1726  #[serde(skip_serializing_if = "Option::is_none")]
1727  pub name: Option<String>,
1728  #[serde(rename = "Description")]
1729  #[serde(skip_serializing_if = "Option::is_none")]
1730  pub description: Option<String>,
1731}
1732
1733#[derive(Debug, Serialize, Deserialize, Clone)]
1734pub struct HWInvByLocOutlet {
1735  #[serde(rename = "ID")]
1736  pub id: String,
1737  #[serde(rename = "Type")]
1738  #[serde(skip_serializing_if = "Option::is_none")]
1739  pub r#type: Option<String>,
1740  #[serde(rename = "Ordinal")]
1741  #[serde(skip_serializing_if = "Option::is_none")]
1742  pub ordinal: Option<u32>,
1743  #[serde(rename = "Status")]
1744  #[serde(skip_serializing_if = "Option::is_none")]
1745  pub status: Option<String>,
1746  #[serde(rename = "HWInventoryByLocationType")]
1747  pub hw_inventory_by_location_type: String,
1748  #[serde(rename = "PopulatedFRU")]
1749  #[serde(skip_serializing_if = "Option::is_none")]
1750  pub populated_fru: Option<HWInventoryByFRU>,
1751  #[serde(rename = "OutletLocationInfo")]
1752  #[serde(skip_serializing_if = "Option::is_none")]
1753  pub outlet_location_info: Option<RedfishOutletLocationInfo>,
1754}
1755
1756#[derive(Debug, Serialize, Deserialize, Clone)]
1757pub struct HWInvByLocPDU {
1758  #[serde(rename = "ID")]
1759  pub id: String,
1760  #[serde(rename = "Type")]
1761  #[serde(skip_serializing_if = "Option::is_none")]
1762  pub r#type: Option<String>,
1763  #[serde(rename = "Ordinal")]
1764  #[serde(skip_serializing_if = "Option::is_none")]
1765  pub ordinal: Option<u32>,
1766  #[serde(rename = "Status")]
1767  #[serde(skip_serializing_if = "Option::is_none")]
1768  pub status: Option<String>,
1769  #[serde(rename = "HWInventoryByLocationType")]
1770  pub hw_inventory_by_location_type: String,
1771  #[serde(rename = "PopulatedFRU")]
1772  #[serde(skip_serializing_if = "Option::is_none")]
1773  pub populated_fru: Option<HWInventoryByFRU>,
1774  #[serde(rename = "PDULocationInfo")]
1775  #[serde(skip_serializing_if = "Option::is_none")]
1776  pub pdu_location_info: Option<RedfishPDULocationInfo>,
1777  #[serde(rename = "CabinetPDUPowerConnectors")]
1778  #[serde(skip_serializing_if = "Option::is_none")]
1779  pub cabinet_pdu_power_connectors: Option<Vec<HWInvByLocOutlet>>,
1780}
1781
1782#[derive(Debug, Serialize, Deserialize, Clone)]
1783pub struct RedfishCMMRectifierLocationInfo {
1784  #[serde(rename = "Name")]
1785  #[serde(skip_serializing_if = "Option::is_none")]
1786  pub name: Option<String>,
1787  #[serde(rename = "FirmwareVersion")]
1788  #[serde(skip_serializing_if = "Option::is_none")]
1789  pub firmware_version: Option<String>,
1790}
1791
1792#[derive(Debug, Serialize, Deserialize, Clone)]
1793pub struct HWInvByLocCMMRectifier {
1794  #[serde(rename = "ID")]
1795  pub id: String,
1796  #[serde(rename = "Type")]
1797  #[serde(skip_serializing_if = "Option::is_none")]
1798  pub r#type: Option<String>,
1799  #[serde(rename = "Ordinal")]
1800  #[serde(skip_serializing_if = "Option::is_none")]
1801  pub ordinal: Option<u32>,
1802  #[serde(rename = "Status")]
1803  #[serde(skip_serializing_if = "Option::is_none")]
1804  pub status: Option<String>,
1805  #[serde(rename = "HWInventoryByLocationType")]
1806  pub hw_inventory_by_location_type: String,
1807  #[serde(rename = "PopulatedFRU")]
1808  #[serde(skip_serializing_if = "Option::is_none")]
1809  pub populated_fru: Option<HWInventoryByFRU>,
1810  #[serde(rename = "CMMRectifierLocationInfo")]
1811  #[serde(skip_serializing_if = "Option::is_none")]
1812  pub cmm_rectifier_location_info: Option<RedfishCMMRectifierLocationInfo>,
1813}
1814
1815#[derive(Debug, Serialize, Deserialize, Clone)]
1816pub struct RedfishNodeEnclosurePowerSupplyLocationInfo {
1817  #[serde(rename = "Name")]
1818  #[serde(skip_serializing_if = "Option::is_none")]
1819  pub name: Option<String>,
1820  #[serde(rename = "FirmwareVersion")]
1821  #[serde(skip_serializing_if = "Option::is_none")]
1822  pub firmware_version: Option<String>,
1823}
1824
1825#[derive(Debug, Serialize, Deserialize, Clone)]
1826pub struct HWInvByLocNodePowerSupply {
1827  #[serde(rename = "ID")]
1828  pub id: String,
1829  #[serde(rename = "Type")]
1830  #[serde(skip_serializing_if = "Option::is_none")]
1831  pub r#type: Option<String>,
1832  #[serde(rename = "Ordinal")]
1833  #[serde(skip_serializing_if = "Option::is_none")]
1834  pub ordinal: Option<u32>,
1835  #[serde(rename = "Status")]
1836  #[serde(skip_serializing_if = "Option::is_none")]
1837  pub status: Option<String>,
1838  #[serde(rename = "HWInventoryByLocationType")]
1839  pub hw_inventory_by_location_type: String,
1840  #[serde(rename = "PopulatedFRU")]
1841  #[serde(skip_serializing_if = "Option::is_none")]
1842  pub populated_fru: Option<HWInventoryByFRU>,
1843  #[serde(rename = "NodeEnclosurePowerSupplyLocationInfo")]
1844  #[serde(skip_serializing_if = "Option::is_none")]
1845  pub node_enclosure_power_supply_location_info:
1846    Option<RedfishNodeEnclosurePowerSupplyLocationInfo>,
1847}
1848
1849#[derive(Debug, Serialize, Deserialize, Clone)]
1850pub struct RedfishManagerLocationInfo {
1851  #[serde(rename = "Id")]
1852  #[serde(skip_serializing_if = "Option::is_none")]
1853  pub id: Option<String>,
1854  #[serde(rename = "Name")]
1855  #[serde(skip_serializing_if = "Option::is_none")]
1856  pub name: Option<String>,
1857  #[serde(rename = "Description")]
1858  #[serde(skip_serializing_if = "Option::is_none")]
1859  pub description: Option<String>,
1860  #[serde(rename = "DateTime")]
1861  #[serde(skip_serializing_if = "Option::is_none")]
1862  pub date_time: Option<String>,
1863  #[serde(rename = "DateTimeLocalOffset")]
1864  #[serde(skip_serializing_if = "Option::is_none")]
1865  pub date_time_local_offset: Option<String>,
1866  #[serde(rename = "FirmwareVersion")]
1867  #[serde(skip_serializing_if = "Option::is_none")]
1868  pub firmware_version: Option<String>,
1869}
1870
1871#[derive(Debug, Serialize, Deserialize, Clone)]
1872pub struct HWInvByLocNodeBMC {
1873  #[serde(rename = "ID")]
1874  pub id: String,
1875  #[serde(rename = "Type")]
1876  #[serde(skip_serializing_if = "Option::is_none")]
1877  pub r#type: Option<String>,
1878  #[serde(rename = "Ordinal")]
1879  #[serde(skip_serializing_if = "Option::is_none")]
1880  pub ordinal: Option<u32>,
1881  #[serde(rename = "Status")]
1882  #[serde(skip_serializing_if = "Option::is_none")]
1883  pub status: Option<String>,
1884  #[serde(rename = "HWInventoryByLocationType")]
1885  pub hw_inventory_by_location_type: String,
1886  #[serde(rename = "PopulatedFRU")]
1887  #[serde(skip_serializing_if = "Option::is_none")]
1888  pub populated_fru: Option<HWInventoryByFRU>,
1889  #[serde(rename = "NodeBMCLocationInfo")]
1890  #[serde(skip_serializing_if = "Option::is_none")]
1891  pub node_bmc_location_info: Option<RedfishManagerLocationInfo>,
1892}
1893
1894#[derive(Debug, Serialize, Deserialize, Clone)]
1895pub struct HWInvByLocRouterBMC {
1896  #[serde(rename = "ID")]
1897  pub id: String,
1898  #[serde(rename = "Type")]
1899  #[serde(skip_serializing_if = "Option::is_none")]
1900  pub r#type: Option<String>,
1901  #[serde(rename = "Ordinal")]
1902  #[serde(skip_serializing_if = "Option::is_none")]
1903  pub ordinal: Option<u32>,
1904  #[serde(rename = "Status")]
1905  #[serde(skip_serializing_if = "Option::is_none")]
1906  pub status: Option<String>,
1907  #[serde(rename = "HWInventoryByLocationType")]
1908  pub hw_inventory_by_location_type: String,
1909  #[serde(rename = "PopulatedFRU")]
1910  #[serde(skip_serializing_if = "Option::is_none")]
1911  pub populated_fru: Option<HWInventoryByFRU>,
1912  #[serde(rename = "RouterBMCLocationInfo")]
1913  #[serde(skip_serializing_if = "Option::is_none")]
1914  pub router_bmc_location_info: Option<RedfishManagerLocationInfo>,
1915}
1916
1917/* #[derive(Debug, Serialize, Deserialize, Clone)]
1918pub struct HWInventoryList {
1919    #[serde(rename = "Hardware")]
1920    pub hw_inventory: Vec<HWInventory>,
1921} */
1922
1923#[derive(Debug, Serialize, Deserialize, Clone)]
1924pub struct HWInventory {
1925  #[serde(rename = "XName")]
1926  #[serde(skip_serializing_if = "Option::is_none")]
1927  pub xname: Option<String>,
1928  #[serde(rename = "Format")]
1929  #[serde(skip_serializing_if = "Option::is_none")]
1930  pub format: Option<String>,
1931  #[serde(rename = "Cabinets")]
1932  #[serde(skip_serializing_if = "Option::is_none")]
1933  pub cabinets: Option<Vec<HWInvByLocCabinet>>,
1934  #[serde(rename = "Chassis")]
1935  #[serde(skip_serializing_if = "Option::is_none")]
1936  pub chassis: Option<Vec<HWInvByLocChassis>>,
1937  #[serde(rename = "ComputeModules")]
1938  #[serde(skip_serializing_if = "Option::is_none")]
1939  pub compute_modules: Option<Vec<HWInvByLocComputeModule>>,
1940  #[serde(rename = "RouterModules")]
1941  #[serde(skip_serializing_if = "Option::is_none")]
1942  pub router_modules: Option<Vec<HWInvByLocRouterModule>>,
1943  #[serde(rename = "NodeEnclosures")]
1944  #[serde(skip_serializing_if = "Option::is_none")]
1945  pub node_enclosures: Option<Vec<HWInvByLocNodeEnclosure>>,
1946  #[serde(rename = "HSNBoards")]
1947  #[serde(skip_serializing_if = "Option::is_none")]
1948  pub hsn_boards: Option<Vec<HWInvByLocHSNBoard>>,
1949  #[serde(rename = "MgmtSwitches")]
1950  #[serde(skip_serializing_if = "Option::is_none")]
1951  pub mgmt_switches: Option<Vec<HWInvByLocMgmtSwitch>>,
1952  #[serde(rename = "MgmtHLSwitches")]
1953  #[serde(skip_serializing_if = "Option::is_none")]
1954  pub mgmt_hl_switches: Option<Vec<HWInvByLocMgmtHLSwitch>>,
1955  #[serde(rename = "CDUMgmtSwitches")]
1956  #[serde(skip_serializing_if = "Option::is_none")]
1957  pub cdu_mgmt_switches: Option<Vec<HWInvByLocCDUMgmtSwitch>>,
1958  #[serde(rename = "Nodes")]
1959  #[serde(skip_serializing_if = "Option::is_none")]
1960  pub nodes: Option<Vec<HWInvByLocNode>>,
1961  #[serde(rename = "Processors")]
1962  #[serde(skip_serializing_if = "Option::is_none")]
1963  pub processors: Option<Vec<HWInvByLocProcessor>>,
1964  #[serde(rename = "NodeAccels")]
1965  #[serde(skip_serializing_if = "Option::is_none")]
1966  pub node_accels: Option<Vec<HWInvByLocNodeAccel>>,
1967  #[serde(rename = "Drives")]
1968  #[serde(skip_serializing_if = "Option::is_none")]
1969  pub drives: Option<Vec<HWInvByLocDrive>>,
1970  #[serde(rename = "Memory")]
1971  #[serde(skip_serializing_if = "Option::is_none")]
1972  pub memory: Option<Vec<HWInvByLocMemory>>,
1973  #[serde(rename = "CabinetPDUs")]
1974  #[serde(skip_serializing_if = "Option::is_none")]
1975  pub cabinet_pdus: Option<Vec<HWInvByLocPDU>>,
1976  #[serde(rename = "CabinetPDUPowerConnectors")]
1977  #[serde(skip_serializing_if = "Option::is_none")]
1978  pub cabinet_pdu_power_connectors: Option<Vec<HWInvByLocOutlet>>,
1979  #[serde(rename = "CMMRectifiers")]
1980  #[serde(skip_serializing_if = "Option::is_none")]
1981  pub cmm_rectifiers: Option<Vec<HWInvByLocCMMRectifier>>,
1982  #[serde(rename = "NodeAccelRisers")]
1983  #[serde(skip_serializing_if = "Option::is_none")]
1984  pub node_accel_risers: Option<Vec<HWInvByLocNodeAccelRiser>>,
1985  #[serde(rename = "NodeHsnNICs")]
1986  #[serde(skip_serializing_if = "Option::is_none")]
1987  pub node_hsn_nics: Option<Vec<HWInvByLocHSNNIC>>,
1988  #[serde(rename = "NodeEnclosurePowerSupplies")]
1989  #[serde(skip_serializing_if = "Option::is_none")]
1990  pub node_enclosure_power_supplies: Option<Vec<HWInvByLocNodePowerSupply>>,
1991  #[serde(rename = "NodeBMC")]
1992  #[serde(skip_serializing_if = "Option::is_none")]
1993  pub node_bmc: Option<Vec<HWInvByLocNodeBMC>>,
1994  #[serde(rename = "RouterBMC")]
1995  #[serde(skip_serializing_if = "Option::is_none")]
1996  pub router_bmc: Option<Vec<HWInvByLocRouterBMC>>,
1997}
1998
1999#[derive(Debug, Serialize, Deserialize, Clone)]
2000pub struct Hardware {
2001  #[serde(rename = "Hardware")]
2002  #[serde(skip_serializing_if = "Option::is_none")]
2003  pub hardware: Option<Vec<HWInvByLocNode>>,
2004}
2005
2006#[derive(Debug, Serialize, Deserialize, Clone)]
2007pub struct NodeLocationInfo {
2008  #[serde(rename = "Id")]
2009  pub id: String,
2010  #[serde(rename = "Name")]
2011  #[serde(skip_serializing_if = "Option::is_none")]
2012  pub name: Option<String>,
2013  #[serde(rename = "Description")]
2014  #[serde(skip_serializing_if = "Option::is_none")]
2015  pub description: Option<String>,
2016  #[serde(rename = "Hostname")]
2017  #[serde(skip_serializing_if = "Option::is_none")]
2018  pub hostname: Option<String>,
2019  #[serde(rename = "ProcessorSummary")]
2020  #[serde(skip_serializing_if = "Option::is_none")]
2021  pub processor_summary: Option<ProcessorSummary>,
2022  #[serde(rename = "MemorySummary")]
2023  #[serde(skip_serializing_if = "Option::is_none")]
2024  pub memory_summary: Option<MemorySummary>,
2025}
2026
2027#[derive(Debug, Serialize, Deserialize, Clone)]
2028#[serde(untagged)] // <-- this is important. More info https://serde.rs/enum-representations.html#untagged
2029pub enum HWInventoryByLocation {
2030  /* HWInvByLocCabinet(HWInvByLocCabinet),
2031  HWInvByLocChassis(HWInvByLocChassis),
2032  HWInvByLocComputeModule(HWInvByLocComputeModule),
2033  HWInvByLocRouterModule(HWInvByLocRouterModule),
2034  HWInvByLocNodeEnclosure(HWInvByLocNodeEnclosure),
2035  HWInvByLocHSNBoard(HWInvByLocHSNBoard),
2036  HWInvByLocMgmtSwitch(HWInvByLocMgmtSwitch),
2037  HWInvByLocMgmtHLSwitch(HWInvByLocMgmtHLSwitch),
2038  HWInvByLocCDUMgmtSwitch(HWInvByLocCDUMgmtSwitch), */
2039  HWInvByLocNode(HWInvByLocNode),
2040  HWInvByLocProcessor(HWInvByLocProcessor),
2041  HWInvByLocNodeAccel(HWInvByLocNodeAccel),
2042  /*     HWInvByLocDrive(HWInvByLocDrive), */
2043  HWInvByLocMemory(HWInvByLocMemory),
2044  /* HWInvByLocPDU(HWInvByLocPDU),
2045  HWInvByLocOutlet(HWInvByLocOutlet),
2046  HWInvByLocCMMRectifier(HWInvByLocCMMRectifier),
2047  HWInvByLocNodeAccelRiser(HWInvByLocNodeAccelRiser), */
2048  HWInvByLocHSNNIC(HWInvByLocHSNNIC),
2049  /* HWInvByLocNodePowerSupply(HWInvByLocNodePowerSupply),
2050  HWInvByLocNodeBMC(HWInvByLocNodeBMC),
2051  HWInvByLocRouterBMC(HWInvByLocRouterBMC), */
2052}
2053
2054/// struct used in POST and GET endpoints that manage multiple instances of 'HWInventoryByLocation'
2055#[derive(Debug, Serialize, Deserialize, Clone)]
2056pub struct HWInventoryByLocationList {
2057  #[serde(rename = "Hardware")]
2058  #[serde(skip_serializing_if = "Option::is_none")]
2059  pub hardware: Option<Vec<HWInventoryByLocation>>,
2060}
manta_backend_dispatcher/types/mod.rs

manta_backend_dispatcher/types/
mod.rs
