feat: initial support of Lenovo SR650 V4 (#23)

These are the following errors we get when trying to generate an
exploration report on Lenovo SR650 V4s. This MR is a first attempt to
fix these issues, more changes coming to support end-to-end ingestion
for this model.

- Missing key `DevicesandIOPorts_SPRedirection` at Systems/1/Bios
- Missing key `DevicesandIOPorts_COMPortActiveAfterBoot` at
Systems/1/Bios
- Missing key `LegacyBIOS_NonOnboardPXE` at Systems/1/Bios
- Missing key `LegacyBIOS_LegacyBIOS` at Systems/1/Bios
- Missing field `ScheduledPowerActions` at redfish/v1/Systems/1/Oem
- Missing field `NumberOfReboots` at redfish/v1/Systems/1/Oem
- Missing field `HistorySysPerformance` at redfish/v1/Systems/1/Oem
- Missing field `TotalPowerOnHours` at redfish/v1/Systems/1/Oem
- Missing field `Sensors` at redfish/v1/Systems/1/Oem
- Missing field `BootSettings` at redfish/v1/Systems/1/Oem

---------

Signed-off-by: Krish Dandiwala <kdandiwala@nvidia.com>

Author: krish-nvidia

src/lenovo.rs

@@ -373,36 +373,46 @@ impl Redfish for Bmc {
     }
 
     async fn setup_serial_console(&self) -> Result<(), RedfishError> {
-        let mut body = HashMap::new();
-        body.insert(
-            "Attributes",
-            HashMap::from([
-                (
-                    "DevicesandIOPorts_COMPort1",
-                    EnabledDisabled::Enabled.to_string(),
-                ),
-                (
-                    "DevicesandIOPorts_ConsoleRedirection",
-                    "Enabled".to_string(), // not an EnabledDisabled, can be "Auto"
-                ),
-                (
-                    "DevicesandIOPorts_SPRedirection",
-                    EnabledDisabled::Enabled.to_string(),
-                ),
-                (
-                    "DevicesandIOPorts_SerialPortSharing",
-                    EnabledDisabled::Enabled.to_string(),
-                ),
-                (
-                    "DevicesandIOPorts_COMPortActiveAfterBoot",
-                    EnabledDisabled::Enabled.to_string(),
-                ),
-                (
-                    "DevicesandIOPorts_SerialPortAccessMode",
-                    "Shared".to_string(),
-                ),
-            ]),
+        let bios = self.bios().await?;
+        let url = format!("Systems/{}/Bios", self.s.system_id());
+        let current_attrs = jsonmap::get_object(&bios, "Attributes", &url)?;
+        
+        let mut attributes = HashMap::new();
+        
+        attributes.insert(
+            "DevicesandIOPorts_COMPort1",
+            EnabledDisabled::Enabled.to_string(),
+        );
+        attributes.insert(
+            "DevicesandIOPorts_ConsoleRedirection",
+            "Enabled".to_string(),
+        );
+        attributes.insert(
+            "DevicesandIOPorts_SerialPortSharing",
+            EnabledDisabled::Enabled.to_string(),
         );
+        attributes.insert(
+            "DevicesandIOPorts_SerialPortAccessMode",
+            EnabledDisabled::Enabled.to_string(),
+        );
+
+        // Only in older Lenovo systems
+        if current_attrs.contains_key("DevicesandIOPorts_SPRedirection") {
+            attributes.insert(
+                "DevicesandIOPorts_SPRedirection",
+                EnabledDisabled::Enabled.to_string(),
+            );
+        }
+        if current_attrs.contains_key("DevicesandIOPorts_COMPortActiveAfterBoot") {
+            attributes.insert(
+                "DevicesandIOPorts_COMPortActiveAfterBoot",
+                EnabledDisabled::Enabled.to_string(),
+            );
+        }
+        
+        let mut body = HashMap::new();
+        body.insert("Attributes", attributes);
+        
         let url = format!("Systems/{}/Bios/Pending", self.s.system_id());
         self.s.client.patch(&url, body).await.map(|_status_code| ())
     }
@@ -412,34 +422,30 @@ impl Redfish for Bmc {
         let bios = self.bios().await?;
         let attrs = jsonmap::get_object(&bios, "Attributes", &url)?;
 
+        // "any" means any value counts as correctly disabled
+        // Attributes are checked if present, missing attributes are skipped
         let expected = vec![
-            // "any" means any value counts as correctly disabled
             ("DevicesandIOPorts_COMPort1", "Enabled", "any"),
             ("DevicesandIOPorts_ConsoleRedirection", "Enabled", "Auto"),
-            ("DevicesandIOPorts_SPRedirection", "Enabled", "Disabled"),
             ("DevicesandIOPorts_SerialPortSharing", "Enabled", "Disabled"),
-            (
-                "DevicesandIOPorts_COMPortActiveAfterBoot",
-                "Enabled",
-                "Disabled",
-            ),
-            (
-                "DevicesandIOPorts_SerialPortAccessMode",
-                "Shared",
-                "Disabled",
-            ),
+            ("DevicesandIOPorts_SPRedirection", "Enabled", "Disabled"),
+            ("DevicesandIOPorts_COMPortActiveAfterBoot", "Enabled", "Disabled"),
+            ("DevicesandIOPorts_SerialPortAccessMode", "Shared", "Disabled"),
         ];
+        
         let mut message = String::new();
         let mut enabled = true;
         let mut disabled = true;
+        
         for (key, val_enabled, val_disabled) in expected {
-            let val_current = jsonmap::get_str(attrs, key, &url)?;
-            message.push_str(&format!("{key}={val_current} "));
-            if val_current != val_enabled {
-                enabled = false;
-            }
-            if val_current != val_disabled && val_disabled != "any" {
-                disabled = false;
+            if let Some(val_current) = attrs.get(key).and_then(|v| v.as_str()) {
+                message.push_str(&format!("{key}={val_current} "));
+                if val_current != val_enabled {
+                    enabled = false;
+                }
+                if val_current != val_disabled && val_disabled != "any" {
+                    disabled = false;
+                }
             }
         }
 
@@ -1372,23 +1378,36 @@ impl Bmc {
     /// Set so that we only UEFI IPv4 HTTP boot, and we retry that.
     ///
     /// Disable PXE Boot
-    /// Disable LegacyBIOS Mode
+    /// Disable LegacyBIOS Mode (if supported)
     /// Set Bootmode to UEFI
     /// Enable IPv4 HTTP Boot
     /// Disable IPv4 PXE Boot
     /// Disable IPv6 PXE Boot
     /// Enable Infinite Boot Mode
     async fn set_uefi_boot_only(&self) -> Result<(), RedfishError> {
+        let bios = self.bios().await?;
+        let url = format!("Systems/{}/Bios", self.s.system_id());
+        let attrs = jsonmap::get_object(&bios, "Attributes", &url)?;
+        
+        let mut attributes = self.uefi_boot_only_attributes();
+        
+        // Legacy BIOS attributes only exist in older systems
+        // Only set them if they're present in the current BIOS
+        if attrs.contains_key("LegacyBIOS_NonOnboardPXE") {
+            attributes.insert("LegacyBIOS_NonOnboardPXE", "Disabled");
+        }
+        if attrs.contains_key("LegacyBIOS_LegacyBIOS") {
+            attributes.insert("LegacyBIOS_LegacyBIOS", "Disabled");
+        }
+        
         let mut body = HashMap::new();
-        body.insert("Attributes", self.uefi_boot_only_attributes());
+        body.insert("Attributes", attributes);
         let url = format!("Systems/{}/Bios/Pending", self.s.system_id());
         self.s.client.patch(&url, body).await.map(|_status_code| ())
     }
 
     fn uefi_boot_only_attributes(&self) -> HashMap<&str, &str> {
         HashMap::from([
-            ("LegacyBIOS_NonOnboardPXE", "Disabled"),
-            ("LegacyBIOS_LegacyBIOS", "Disabled"),
             ("BootModes_SystemBootMode", "UEFIMode"),
             ("NetworkStackSettings_IPv4HTTPSupport", "Enabled"),
             ("NetworkStackSettings_IPv4PXESupport", "Disabled"),

src/model/oem/lenovo.rs

@@ -38,18 +38,18 @@ pub struct RecipientSettings {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "PascalCase")]
 pub struct System {
-    pub scheduled_power_actions: ODataId,
+    pub scheduled_power_actions: Option<ODataId>,
     #[serde(rename = "FrontPanelUSB")]
     pub front_panel_usb: Option<FrontPanelUSB>,
     pub metrics: ODataId,
     pub system_status: String,
-    pub number_of_reboots: i64,
-    pub history_sys_perf: ODataId,
+    pub number_of_reboots: Option<i64>,
+    pub history_sys_perf: Option<ODataId>,
     #[serde(rename = "@odata.type")]
     pub odata_type: String,
-    pub total_power_on_hours: i64,
-    pub sensors: ODataId,
-    pub boot_settings: ODataId,
+    pub total_power_on_hours: Option<i64>,
+    pub sensors: Option<ODataId>,
+    pub boot_settings: Option<ODataId>,
 }
 
 /* Front Panel USB Port Management mapping from UI to redfish API:
@@ -76,10 +76,13 @@ pub struct System {
 pub struct FrontPanelUSB {
     inactivity_timeout_mins: i64,
     #[serde(rename = "IDButton")]
-    id_button: String,
+    id_button: Option<String>, // Only in older Lenovo systems
     pub port_switching_to: PortSwitchingMode,
     #[serde(rename = "FPMode")]
     pub fp_mode: FrontPanelUSBMode,
+    // Fields in newer Lenovo systems
+    port_id: Option<String>,
+    status: Option<String>,
 }
 
 #[allow(clippy::upper_case_acronyms)]

src/model/system.rs

@@ -212,7 +212,7 @@ pub struct ComputerSystemLinks {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "PascalCase")]
 pub struct SerialConsole {
-    pub max_concurrent_sessions: usize,
+    pub max_concurrent_sessions: Option<usize>,
     #[serde(rename = "SSH")]
     pub ssh: SerialConsoleConnectionType,
     #[serde(rename = "IPMI")]
@@ -418,7 +418,7 @@ mod test {
         let result: super::ComputerSystem = serde_json::from_str(data).unwrap();
         assert_eq!(
             result.oem.unwrap().lenovo.unwrap().total_power_on_hours,
-            3816
+            Some(3816)
         );
         assert_eq!(result.processor_summary.unwrap().count, Some(2));
     }

src/supermicro.rs

@@ -316,7 +316,7 @@ impl Redfish for Bmc {
             ));
         };
         let is_enabled = sr.ssh.service_enabled
-            && sr.max_concurrent_sessions != 0
+            && sr.max_concurrent_sessions != Some(0)
             && s_interface.is_supermicro_default();
         let status = if is_enabled {
             StatusInternal::Enabled