supermicro 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7b045637afdfc22ca25c75e6acd7cf8880a8b8fcd55db67a3aebf5bc8e7875c
-  data.tar.gz: 90f5b3cae2874bb7511e087b03cd4940e1b2594ddafed3f864aa486fdd7abc2a
+  metadata.gz: d4f04d1c98be296a5225792fbf6cfc9058491f92f971e8fdf80e47c513e23579
+  data.tar.gz: 158c91f61686c85a89bc0040157c80089ee32e2398bc58bf675d176da405a4c4
 SHA512:
-  metadata.gz: '0835ab4b24a469bc013afba3f514f66b86d15d1578785284d2007720aa4065b84db873a49d5c8de9447ce47329926fa9ec13794995916569d8258b495cc0bd0f'
-  data.tar.gz: 430d94eda6451653864324f62002cb42e9ce15e7b7bb27f27a222ce3e24f59b369b3870a253f08ef478a899dcbf13f16c444ece56e1cb0e2b17972ca7a5fe954
+  metadata.gz: 948f17fa2f9d675bd2969e420ec248c57b9fbcab76ecc06680be3782a050db3feb0c6151fadeba82593242e293fb1f70048b49b046776aea984d8bc487f6d3cc
+  data.tar.gz: 496257525cda3c494c7e619eee1fb25258c07382803cc5f68df9486cbe430773981ca9d2dacac08853f325abf4139884562fdfc7a77c1be9dc852d323e07b7f8

data/lib/supermicro/bios.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Supermicro
+  module Bios
+    # Get BIOS attributes (public method for adapter compatibility)
+    def bios_attributes
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Bios")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          {
+            "attributes" => data["Attributes"],
+            "attribute_registry" => data["AttributeRegistry"]
+          }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse BIOS attributes response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get BIOS attributes. Status code: #{response.status}"
+      end
+    end
+    
+    # Get just the attributes hash (private helper)
+    private
+    def get_bios_attributes
+      result = bios_attributes
+      result["attributes"] || {}
+    rescue
+      {}
+    end
+    public
+    
+    # Check if BIOS error prompt is disabled
+    # Supermicro equivalent: WaitFor_F1_IfError should be "Disabled"
+    def bios_error_prompt_disabled?
+      attrs = get_bios_attributes
+      
+      if attrs.has_key?("WaitFor_F1_IfError")
+        return attrs["WaitFor_F1_IfError"] == "Disabled"
+      else
+        debug "WaitFor_F1_IfError attribute not found in BIOS settings", 1, :yellow
+        return false
+      end
+    end
+    
+    # Check if HDD placeholder is enabled
+    # Supermicro doesn't have a direct equivalent to Dell's HddPlaceholder
+    # This is a no-op that returns true for compatibility
+    def bios_hdd_placeholder_enabled?
+      # Supermicro automatically handles boot device placeholders
+      # No explicit setting needed
+      true
+    end
+    
+    # Check if OS power control is enabled
+    # Supermicro equivalent: Check power management settings
+    # PowerPerformanceTuning should be "OS Controls EPB" for OS control
+    def bios_os_power_control_enabled?
+      attrs = get_bios_attributes
+      
+      # Check if OS is controlling power management
+      if attrs.has_key?("PowerPerformanceTuning")
+        return attrs["PowerPerformanceTuning"] == "OS Controls EPB"
+      else
+        # If the setting doesn't exist, assume it's not configured
+        debug "PowerPerformanceTuning attribute not found in BIOS settings", 1, :yellow
+        return false
+      end
+    end
+    
+    # Set BIOS error prompt behavior
+    def set_bios_error_prompt(disabled: true)
+      value = disabled ? "Disabled" : "Enabled"
+      
+      payload = {
+        "Attributes" => {
+          "WaitFor_F1_IfError" => value
+        }
+      }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Systems/1/Bios/SD",
+        body: payload.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "BIOS error prompt #{disabled ? 'disabled' : 'enabled'} successfully", 1, :green
+        true
+      else
+        debug "Failed to set BIOS error prompt. Status: #{response.status}", 0, :red
+        false
+      end
+    end
+    
+    # Set OS power control
+    def set_bios_os_power_control(enabled: true)
+      value = enabled ? "OS Controls EPB" : "BIOS Controls EPB"
+      
+      payload = {
+        "Attributes" => {
+          "PowerPerformanceTuning" => value
+        }
+      }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Systems/1/Bios/SD",
+        body: payload.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "OS power control #{enabled ? 'enabled' : 'disabled'} successfully", 1, :green
+        true
+      else
+        debug "Failed to set OS power control. Status: #{response.status}", 0, :red
+        false
+      end
+    end
+    
+    # Ensure UEFI boot mode
+    def ensure_uefi_boot
+      attrs = get_bios_attributes
+      
+      # Check current boot mode
+      current_mode = attrs["BootModeSelect"]
+      
+      if current_mode == "UEFI"
+        debug "System is already in UEFI boot mode", 1, :green
+        return true
+      else
+        debug "System is not in UEFI boot mode (current: #{current_mode}). Setting to UEFI...", 1, :yellow
+        
+        # Set UEFI boot mode
+        payload = {
+          "Attributes" => {
+            "BootModeSelect" => "UEFI"
+          }
+        }
+        
+        response = authenticated_request(
+          :patch,
+          "/redfish/v1/Systems/1/Bios/SD",
+          body: payload.to_json,
+          headers: { 'Content-Type': 'application/json' }
+        )
+        
+        if response.status.between?(200, 299)
+          debug "UEFI boot mode configured successfully", 1, :green
+          debug "Note: A reboot is required for the change to take effect", 1, :yellow
+          return true
+        else
+          debug "Failed to set UEFI boot mode. Status: #{response.status}", 0, :red
+          debug "Response: #{response.body}", 2, :red
+          return false
+        end
+      end
+    end
+    
+    # Ensure sensible BIOS settings (Supermicro version)
+    def ensure_sensible_bios!(options = {})
+      # Check current state
+      if bios_error_prompt_disabled? && bios_os_power_control_enabled?
+        debug "BIOS settings already configured correctly", 1, :green
+        return { changes_made: false }
+      end
+      
+      debug "Configuring BIOS settings...", 1, :yellow
+      
+      # Build the attributes to change
+      attributes = {}
+      
+      # Check and prepare error prompt change
+      if !bios_error_prompt_disabled?
+        debug "Will disable BIOS error prompt (F1 wait)", 1, :yellow
+        attributes["WaitFor_F1_IfError"] = "Disabled"
+      end
+      
+      # Check and prepare OS power control change
+      if !bios_os_power_control_enabled?
+        debug "Will enable OS power control", 1, :yellow
+        attributes["PowerPerformanceTuning"] = "OS Controls EPB"
+      end
+      
+      # Ensure UEFI boot mode
+      attributes["BootModeSelect"] = "UEFI"
+      
+      # Apply all changes at once
+      payload = { "Attributes" => attributes }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Systems/1/Bios/SD",
+        body: payload.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "BIOS settings configured successfully", 1, :green
+        
+        # Check if a reboot job was created
+        if response.headers['Location']
+          debug "BIOS change job created: #{response.headers['Location']}", 1, :yellow
+        end
+        
+        return { changes_made: true }
+      else
+        debug "Failed to apply BIOS settings. Status: #{response.status}", 0, :red
+        debug "Response: #{response.body}", 2, :red
+        return { changes_made: false, error: "Failed to apply BIOS settings" }
+      end
+    end
+    
+    # Set individual BIOS attribute
+    def set_bios_attribute(attribute_name, value)
+      debug "Setting BIOS attribute #{attribute_name} to #{value}...", 1, :yellow
+      
+      body = {
+        "Attributes" => {
+          attribute_name => value
+        }
+      }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Systems/1/Bios/SD",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "BIOS attribute set successfully. Changes will be applied on next reboot.", 1, :green
+        return true
+      else
+        raise Error, "Failed to set BIOS attribute: #{response.status} - #{response.body}"
+      end
+    end
+
+    def pending_bios_settings
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Bios/SD")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          data["Attributes"] || {}
+        rescue JSON::ParserError
+          raise Error, "Failed to parse pending BIOS settings response: #{response.body}"
+        end
+      else
+        {}
+      end
+    end
+
+    def reset_bios_defaults
+      debug "Resetting BIOS to defaults...", 1, :yellow
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios",
+        body: {}.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "BIOS reset to defaults successfully. Changes will be applied on next reboot.", 1, :green
+        return true
+      else
+        raise Error, "Failed to reset BIOS: #{response.status} - #{response.body}"
+      end
+    end
+  end
+end

data/lib/supermicro/boot.rb

@@ -5,63 +5,100 @@ require 'colorize'
 
 module Supermicro
   module Boot
-    def boot_options
+    # Get boot configuration with snake_case fields
+    def boot_config
       response = authenticated_request(:get, "/redfish/v1/Systems/1")
       
       if response.status == 200
         begin
           data = JSON.parse(response.body)
+          boot_data = data["Boot"] || {}
+          
+          # Get boot options for resolving references
+          options_map = {}
+          begin
+            options = boot_options
+            options.each do |opt|
+              options_map[opt["id"]] = opt["display_name"] || opt["name"]
+            end
+          rescue
+            # Ignore errors fetching boot options
+          end
           
-          boot_info = data["Boot"] || {}
+          # Build boot order with resolved names
+          boot_order = (boot_data["BootOrder"] || []).map do |ref|
+            {
+              "reference" => ref,
+              "name" => options_map[ref] || ref
+            }
+          end
           
+          # Return hash with snake_case fields
           {
-            "boot_source_override_enabled" => boot_info["BootSourceOverrideEnabled"],
-            "boot_source_override_target" => boot_info["BootSourceOverrideTarget"],
-            "boot_source_override_mode" => boot_info["BootSourceOverrideMode"],
-            "allowed_targets" => boot_info["BootSourceOverrideTarget@Redfish.AllowableValues"],
-            "boot_options" => boot_info["BootOptions"],
-            "boot_order" => boot_info["BootOrder"],
-            "uefi_target" => boot_info["UefiTargetBootSourceOverride"]
-          }
+            # Boot override settings (for one-time or continuous boot)
+            "boot_source_override_enabled" => boot_data["BootSourceOverrideEnabled"],     # Disabled/Once/Continuous
+            "boot_source_override_target" => boot_data["BootSourceOverrideTarget"],       # None/Pxe/Hdd/Cd/etc
+            "boot_source_override_mode" => boot_data["BootSourceOverrideMode"],           # UEFI/Legacy
+            "allowed_override_targets" => boot_data["BootSourceOverrideTarget@Redfish.AllowableValues"] || [],
+            
+            # Permanent boot order with resolved names
+            "boot_order" => boot_order,                                                    # [{reference: "Boot0002", name: "PXE IPv4"}]
+            "boot_order_refs" => boot_data["BootOrder"] || [],                            # Raw references for set_boot_order
+            
+            # Supermicro specific fields
+            "boot_next" => boot_data["BootNext"],
+            "http_boot_uri" => boot_data["HttpBootUri"],
+            
+            # References to other resources
+            "boot_options_uri" => boot_data.dig("BootOptions", "@odata.id")
+          }.compact
         rescue JSON::ParserError
-          raise Error, "Failed to parse boot options response: #{response.body}"
+          raise Error, "Failed to parse boot response: #{response.body}"
         end
       else
-        raise Error, "Failed to get boot options. Status code: #{response.status}"
+        raise Error, "Failed to get boot configuration. Status code: #{response.status}"
       end
     end
-
-    def set_boot_override(target, persistence: nil, mode: nil, persistent: false)
-      valid_targets = boot_options["allowed_targets"]
+    
+    # Get raw Redfish boot data (CamelCase)
+    def boot_raw
+      response = authenticated_request(:get, "/redfish/v1/Systems/1")
       
-      unless valid_targets&.include?(target)
-        debug "Invalid boot target. Allowed values:"
-        valid_targets&.each { |t| debug "  - #{t}" }
-        raise Error, "Invalid boot target: #{target}"
+      if response.status == 200
+        data = JSON.parse(response.body)
+        data["Boot"] || {}
+      else
+        raise Error, "Failed to get boot configuration. Status code: #{response.status}"
       end
+    end
+    
+    # Shorter alias for convenience  
+    def boot
+      boot_config
+    end
+
+    # Set boot override for next boot
+    def set_boot_override(target, enabled: "Once", mode: nil)
+      # Validate target against allowed values
+      boot_data = boot
+      valid_targets = boot_data["allowed_override_targets"]
       
-      # Handle both old persistent parameter and new persistence parameter
-      enabled = if persistence
-        persistence  # Use new parameter if provided
-      elsif persistent
-        "Continuous"  # Legacy support
-      else
-        "Once"  # Default
+      if valid_targets && !valid_targets.include?(target)
+        debug "Invalid boot target '#{target}'. Allowed values: #{valid_targets.join(', ')}"
+        raise Error, "Invalid boot target: #{target}"
       end
       
       debug "Setting boot override to #{target} (#{enabled})..."
       
       body = {
         "Boot" => {
-          "BootSourceOverrideEnabled" => enabled,
-          "BootSourceOverrideTarget" => target
+          "BootSourceOverrideEnabled" => enabled,  # Disabled/Once/Continuous
+          "BootSourceOverrideTarget" => target     # None/Pxe/Hdd/Cd/etc
         }
       }
       
       # Add boot mode if specified
-      if mode
-        body["Boot"]["BootSourceOverrideMode"] = mode
-      end
+      body["Boot"]["BootSourceOverrideMode"] = mode if mode
       
       response = authenticated_request(
         :patch,
@@ -156,51 +193,147 @@ module Supermicro
       end
     end
 
-    def get_boot_devices
-      response = authenticated_request(:get, "/redfish/v1/Systems/1/BootOptions?$expand=*($levels=1)")
+    # Get boot options collection (detailed boot devices) with snake_case
+    def boot_options
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/BootOptions")
       
       if response.status == 200
         begin
           data = JSON.parse(response.body)
+          options = []
           
-          devices = data["Members"]&.map do |device|
-            {
-              "id" => device["Id"],
-              "name" => device["DisplayName"] || device["Name"],
-              "description" => device["Description"],
-              "boot_option_reference" => device["BootOptionReference"],
-              "enabled" => device["BootOptionEnabled"],
-              "uefi_device_path" => device["UefiDevicePath"]
-            }
-          end || []
+          # Supermicro doesn't support $expand, fetch each individually
+          data["Members"]&.each do |member|
+            if member["@odata.id"]
+              opt_response = authenticated_request(:get, member["@odata.id"])
+              if opt_response.status == 200
+                opt_data = JSON.parse(opt_response.body)
+                options << {
+                  "id" => opt_data["Id"],                                           # Boot0002
+                  "boot_option_reference" => opt_data["BootOptionReference"],       # Boot0002
+                  "display_name" => opt_data["DisplayName"],                        # "UEFI PXE IPv4: Intel..."
+                  "name" => opt_data["DisplayName"] || opt_data["Name"],            # Alias for display_name
+                  "enabled" => opt_data["BootOptionEnabled"],                       # true/false
+                  "uefi_device_path" => opt_data["UefiDevicePath"],                 # UEFI device path if present
+                  "description" => opt_data["Description"]
+                }.compact
+              end
+            end
+          end
           
-          return devices
+          options
         rescue JSON::ParserError
-          raise Error, "Failed to parse boot devices response: #{response.body}"
+          raise Error, "Failed to parse boot options response: #{response.body}"
         end
       else
         []
       end
     end
+    
+    # Alias for backwards compatibility
+    def get_boot_devices
+      boot_options
+    end
 
-    def boot_to_pxe(persistence: nil, mode: nil)
-      set_boot_override("Pxe", persistence: persistence, mode: mode)
+    # Convenience methods for common boot targets
+    def boot_to_pxe(enabled: "Once", mode: nil)
+      set_boot_override("Pxe", enabled: enabled, mode: mode)
     end
 
-    def boot_to_disk(persistence: nil, mode: nil)
-      set_boot_override("Hdd", persistence: persistence, mode: mode)
+    def boot_to_disk(enabled: "Once", mode: nil)
+      set_boot_override("Hdd", enabled: enabled, mode: mode)
     end
 
-    def boot_to_cd(persistence: nil, mode: nil)
-      set_boot_override("Cd", persistence: persistence, mode: mode)
+    def boot_to_cd(enabled: "Once", mode: "UEFI")
+      # Always use UEFI mode for CD boot since we're booting UEFI media
+      set_boot_override("Cd", enabled: enabled, mode: mode)
     end
 
-    def boot_to_usb(persistence: nil, mode: nil)
-      set_boot_override("Usb", persistence: persistence, mode: mode)
+    def boot_to_usb(enabled: "Once", mode: nil)
+      set_boot_override("Usb", enabled: enabled, mode: mode)
     end
 
-    def boot_to_bios_setup(persistence: nil, mode: nil)
-      set_boot_override("BiosSetup", persistence: persistence, mode: mode)
+    def boot_to_bios_setup(enabled: "Once", mode: nil)
+      set_boot_override("BiosSetup", enabled: enabled, mode: mode)
+    end
+    
+    # Set one-time boot to virtual media (CD)
+    def set_one_time_boot_to_virtual_media
+      debug "Setting one-time boot to virtual media...", 1, :yellow
+      
+      # Supermicro often needs virtual media remounted to ensure it's properly recognized
+      # Check if virtual media is already mounted and remount if so
+      begin
+        require_relative 'virtual_media'
+        vm_status = virtual_media_status
+        
+        if vm_status && vm_status["Inserted"]
+          current_image = vm_status["Image"]
+          if current_image
+            debug "Remounting virtual media to ensure fresh connection...", 1, :yellow
+            
+            # Eject current media
+            eject_virtual_media rescue nil
+            sleep 2
+            
+            # Re-insert the media
+            insert_virtual_media(current_image)
+            sleep 3
+            
+            debug "Virtual media remounted: #{current_image}", 1, :green
+          end
+        end
+      rescue => e
+        debug "Note: Could not remount virtual media: #{e.message}", 2, :yellow
+      end
+      
+      # Now try the standard boot override - this often works after remount
+      result = boot_to_cd(enabled: "Once")
+      
+      if result
+        debug "One-time boot to virtual media configured", 1, :green
+        debug "System will boot from virtual CD on next restart", 1, :green
+      else
+        debug "Failed to set boot override, may need manual intervention", 1, :red
+      end
+      
+      result
+    end
+    
+    # Set boot order with hard drive first
+    def set_boot_order_hd_first
+      debug "Configuring system to boot from HD after OS installation...", 1, :yellow
+      
+      # First check if there's actually a hard disk present
+      boot_opts = boot_options
+      hd_option = boot_opts.find { |opt| 
+        opt["display_name"] =~ /Hard Drive|HDD|SATA|NVMe|SSD|RAID|UEFI OS/i 
+      }
+      
+      if hd_option
+        # HD exists, set it as first in boot order
+        other_options = boot_opts.select { |opt| 
+          opt["enabled"] && opt["id"] != hd_option["id"]
+        }.sort_by { |opt| opt["id"] }
+        
+        new_order = [hd_option["id"]] + other_options.map { |opt| opt["id"] }
+        debug "Setting boot order with HD first: #{new_order.join(', ')}", 2, :yellow
+        result = set_boot_order(new_order)
+        
+        if result
+          debug "Boot order set with HD first", 1, :green
+        end
+      else
+        # No HD yet - this is expected before OS install
+        # DO NOT clear boot overrides as that would clear one-time boot settings
+        # Just log that HD will be available after OS install
+        debug "No HD found yet (expected before OS install)", 1, :yellow
+        debug "HD will become available after OS installation", 1, :yellow
+        debug "System will boot from HD naturally after the one-time virtual media boot", 1, :yellow
+        result = true  # Return success since this is expected
+      end
+      
+      result
     end
   end
 end

data/lib/supermicro/client.rb

@@ -21,6 +21,7 @@ module Supermicro
     include System
     include VirtualMedia
     include Boot
+    include Bios
     include SystemConfig
     include Utility
     include License