radfish-supermicro 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18b3105e8896a1e7dfa12dc175a99295e8121da3a69c7c0f1dda6ebd0ee0b455
-  data.tar.gz: 4b6f0773585b541e884b17f357a21ad2d35f7e072a35550cb5d03913abda17ba
+  metadata.gz: 499189bee910ae6a2e0e988ae483da3942747a82eed4c92ea135d6860e7cadb5
+  data.tar.gz: 64c25e2b26bda44fee6d22a67a5810bb360abfcd81519383fa9468af3d556686
 SHA512:
-  metadata.gz: ef902816879796e5f2d04b7997475c9f2ee30584a4cb2e2c580e73ab89f38a5c12fefaa9b4278a74be0fdc0d128d42b6fa035c6c79188e5f66789bbc35d99b3e
-  data.tar.gz: 79d4631297df50b06e7d59d81a9d51af8f849eaf6bed1733596f61207aa63bf21e1ea96fca84990e490c8d61f15be9e9b017f1f5e10ef7345492b30e80162dbf
+  metadata.gz: 9914c96b7ac2f16af5ea3503b4dd0ae651ba27eb051475f33abd1af90d0d5a60f09eff180ce62260b55f42d5cc52cebcffb0e4c72a2375db541cb864be3416d9
+  data.tar.gz: 36fb04d97574bfcb12db4e92616f328bbf5147a9cfaa8a9508e6b150560d72b0ce2c45d5fdb4a5420bb11640a563fb5adec3eef7af54a9d3a52e01af09009962

data/lib/radfish/supermicro/version.rb

@@ -2,6 +2,6 @@
 
 module Radfish
   module Supermicro
-    VERSION = "0.1.2"
+    VERSION = "0.1.4"
   end
 end

data/lib/radfish/supermicro_adapter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'supermicro'
+require 'ostruct'
 
 module Radfish
   class SupermicroAdapter < Core::BaseClient
@@ -11,6 +12,7 @@ module Radfish
     include Core::Boot
     include Core::Jobs
     include Core::Utility
+    include Core::Network
     
     attr_reader :supermicro_client
     
@@ -61,20 +63,106 @@ module Radfish
       @supermicro_client.power_status
     end
     
-    def power_on
-      @supermicro_client.power_on
+    def power_on(wait: true)
+      result = @supermicro_client.power_on
+      
+      if wait && result
+        # Wait for power on to complete
+        max_attempts = 30
+        attempts = 0
+        while attempts < max_attempts
+          sleep 2
+          begin
+            status = @supermicro_client.power_status
+            break if status == "On"
+          rescue => e
+            # BMC might be temporarily unavailable during power operations
+            debug "Waiting for BMC to respond: #{e.message}", 1, :yellow
+          end
+          attempts += 1
+        end
+      end
+      
+      result
     end
     
-    def power_off(force: false)
-      @supermicro_client.power_off(force: force)
+    def power_off(type: "GracefulShutdown", wait: true)
+      # Translate Redfish standard types to Supermicro's force parameter
+      force = (type == "ForceOff")
+      result = @supermicro_client.power_off(force: force)
+      
+      if wait && result
+        # Wait for power off to complete
+        max_attempts = 30
+        attempts = 0
+        while attempts < max_attempts
+          sleep 2
+          begin
+            status = @supermicro_client.power_status
+            break if status == "Off"
+          rescue => e
+            # BMC might be temporarily unavailable during power operations
+            debug "Waiting for BMC to respond: #{e.message}", 1, :yellow
+          end
+          attempts += 1
+        end
+      end
+      
+      result
     end
     
-    def power_restart(force: false)
-      @supermicro_client.power_restart(force: force)
+    def reboot(type: "GracefulRestart", wait: true)
+      # Translate Redfish standard types to Supermicro's force parameter
+      force = (type == "ForceRestart")
+      result = @supermicro_client.power_restart(force: force)
+      
+      if wait && result
+        # Wait for system to go down then come back up
+        max_attempts = 60
+        attempts = 0
+        went_down = false
+        
+        while attempts < max_attempts
+          sleep 2
+          begin
+            status = @supermicro_client.power_status
+            went_down = true if status == "Off" && !went_down
+            break if went_down && status == "On"
+          rescue => e
+            # BMC might be temporarily unavailable during reboot
+            debug "Waiting for BMC during reboot: #{e.message}", 1, :yellow
+          end
+          attempts += 1
+        end
+      end
+      
+      result
     end
     
-    def power_cycle
-      @supermicro_client.power_cycle
+    def power_cycle(wait: true)
+      result = @supermicro_client.power_cycle
+      
+      if wait && result
+        # Wait for system to go down then come back up
+        max_attempts = 60
+        attempts = 0
+        went_down = false
+        
+        while attempts < max_attempts
+          sleep 2
+          begin
+            status = @supermicro_client.power_status
+            went_down = true if status == "Off" && !went_down
+            break if went_down && status == "On"
+          rescue => e
+            # BMC might be temporarily unavailable during power cycle
+            debug "Waiting for BMC during power cycle: #{e.message}", 1, :yellow
+          end
+          attempts += 1
+        end
+      end
+      
+      result
     end
     
     def reset_type_allowed
@@ -84,31 +172,94 @@ module Radfish
     # System information
     
     def system_info
-      @supermicro_client.system_info
+      # Supermicro gem returns string keys, convert to symbols for radfish
+      info = @supermicro_client.system_info
+      
+      # Use minimal naming approach for consistency across systems
+      # Normalize manufacturer/make to just "Supermicro"
+      manufacturer = info["manufacturer"]
+      if manufacturer
+        # Strip "Super Micro", "Super Micro Computer", etc. to just "Supermicro"
+        manufacturer = manufacturer.gsub(/Super\s*Micro(\s+Computer.*)?/i, 'Supermicro')
+      end
+      
+      # Extract service tag from Manager UUID (BMC MAC address)
+      # Manager UUID format: 00000000-0000-0000-0000-XXXXXXXXXXXX
+      # Service tag is the last XXXXXXXXXXXX part (BMC MAC without colons)
+      service_tag = info["manager_uuid"]&.split('-')&.last || info["serial"]
+      
+      {
+        service_tag: service_tag,  # Last block of UUID or fallback to serial
+        manufacturer: manufacturer,
+        make: manufacturer,
+        model: info["model"],
+        serial: info["serial"],
+        serial_number: info["serial"],
+        name: info["name"],
+        uuid: info["uuid"],
+        bios_version: info["bios_version"],
+        power_state: info["power_state"],
+        health: info["health"]
+      }.compact
     end
     
     def cpus
-      @supermicro_client.cpus
+      # The supermicro gem returns an array of CPU hashes
+      # Convert them to OpenStruct objects for dot notation access
+      cpu_data = @supermicro_client.cpus
+      
+      cpu_data.map do |cpu|
+        OpenStruct.new(
+          socket: cpu["socket"],
+          manufacturer: cpu["manufacturer"],
+          model: cpu["model"],
+          speed_mhz: cpu["speed_mhz"],
+          cores: cpu["cores"],
+          threads: cpu["threads"],
+          health: cpu["health"]
+        )
+      end
     end
     
     def memory
-      @supermicro_client.memory
+      mem_data = @supermicro_client.memory
+      return [] unless mem_data
+      
+      # Convert to OpenStruct for dot notation access
+      mem_data.map { |m| OpenStruct.new(m) }
     end
     
     def nics
-      @supermicro_client.nics
+      nic_data = @supermicro_client.nics
+      return [] unless nic_data
+      
+      # Convert to OpenStruct for dot notation access, including nested ports
+      nic_data.map do |nic|
+        if nic["ports"]
+          nic["ports"] = nic["ports"].map { |port| OpenStruct.new(port) }
+        end
+        OpenStruct.new(nic)
+      end
     end
     
     def fans
-      @supermicro_client.fans
+      # Convert hash array to OpenStruct objects for dot notation access
+      fan_data = @supermicro_client.fans
+      
+      fan_data.map do |fan|
+        OpenStruct.new(fan)
+      end
     end
     
-    def temperatures
-      @supermicro_client.temperatures
-    end
+    # Note: Supermicro doesn't provide a temperatures method
     
     def psus
-      @supermicro_client.psus
+      # Convert hash array to OpenStruct objects for dot notation access
+      psu_data = @supermicro_client.psus
+      
+      psu_data.map do |psu|
+        OpenStruct.new(psu)
+      end
     end
     
     def power_consumption
@@ -124,7 +275,16 @@ module Radfish
     # Storage
     
     def storage_controllers
-      @supermicro_client.storage_controllers
+      # Convert hash array to OpenStruct objects for dot notation access
+      controller_data = @supermicro_client.storage_controllers
+      
+      controller_data.map do |controller|
+        # Convert drives array to OpenStruct objects if present
+        if controller["drives"]
+          controller["drives"] = controller["drives"].map { |drive| OpenStruct.new(drive) }
+        end
+        OpenStruct.new(controller)
+      end
     end
     
     def drives
@@ -147,10 +307,37 @@ module Radfish
     
     def insert_virtual_media(iso_url, device: nil)
       @supermicro_client.insert_virtual_media(iso_url, device: device)
+    rescue Supermicro::Error => e
+      # Translate Supermicro errors to Radfish errors with context
+      error_message = e.message
+      
+      if error_message.include?("connection refused") || error_message.include?("port number")
+        raise Radfish::VirtualMediaConnectionError, "BMC cannot reach ISO server: #{error_message}"
+      elsif error_message.include?("NotConnected") || error_message.include?("not connected")
+        raise Radfish::VirtualMediaConnectionError, "Virtual media failed to connect properly: #{error_message}"
+      elsif error_message.include?("license") || error_message.include?("SFT-OOB-LIC")
+        raise Radfish::VirtualMediaLicenseError, "Virtual media license required: #{error_message}"
+      elsif error_message.include?("already inserted") || error_message.include?("busy")
+        raise Radfish::VirtualMediaBusyError, "Virtual media device busy: #{error_message}"
+      elsif error_message.include?("not found") || error_message.include?("No suitable")
+        raise Radfish::VirtualMediaNotFoundError, "Virtual media device not found: #{error_message}"
+      elsif error_message.include?("timeout")
+        raise Radfish::TaskTimeoutError, "Virtual media operation timed out: #{error_message}"
+      else
+        # Generic virtual media error
+        raise Radfish::VirtualMediaError, error_message
+      end
     end
     
     def eject_virtual_media(device: nil)
       @supermicro_client.eject_virtual_media(device: device)
+    rescue Supermicro::Error => e
+      # Translate errors consistently
+      if e.message.include?("not found") || e.message.include?("No suitable")
+        raise Radfish::VirtualMediaNotFoundError, "Virtual media device not found: #{e.message}"
+      else
+        raise Radfish::VirtualMediaError, "Failed to eject virtual media: #{e.message}"
+      end
     end
     
     def virtual_media_status
@@ -167,16 +354,24 @@ module Radfish
     
     # Boot configuration
     
+    def boot_config
+      # Return hash for consistent data structure
+      @supermicro_client.boot_config
+    end
+    
+    # Shorter alias for convenience
+    def boot
+      boot_config
+    end
+    
     def boot_options
-      @supermicro_client.boot_options
+      # Return array of OpenStructs for boot options
+      options = @supermicro_client.boot_options
+      options.map { |opt| OpenStruct.new(opt) }
     end
     
-    def set_boot_override(target, persistence: nil, mode: nil, persistent: false)
-      # Pass all parameters through to the supermicro client
-      @supermicro_client.set_boot_override(target, 
-                                          persistence: persistence,
-                                          mode: mode,
-                                          persistent: persistent)
+    def set_boot_override(target, enabled: "Once", mode: nil)
+      @supermicro_client.set_boot_override(target, enabled: enabled, mode: mode)
     end
     
     def clear_boot_override
@@ -191,30 +386,78 @@ module Radfish
       @supermicro_client.get_boot_devices
     end
     
-    def boot_to_pxe(persistence: nil, mode: nil)
-      @supermicro_client.boot_to_pxe(persistence: persistence, mode: mode)
+    def boot_to_pxe(enabled: "Once", mode: nil)
+      @supermicro_client.boot_to_pxe(enabled: enabled, mode: mode)
     end
     
-    def boot_to_disk(persistence: nil, mode: nil)
-      @supermicro_client.boot_to_disk(persistence: persistence, mode: mode)
+    def boot_to_disk(enabled: "Once", mode: nil)
+      @supermicro_client.boot_to_disk(enabled: enabled, mode: mode)
     end
     
-    def boot_to_cd(persistence: nil, mode: nil)
-      @supermicro_client.boot_to_cd(persistence: persistence, mode: mode)
+    def boot_to_cd(enabled: "Once", mode: nil)
+      @supermicro_client.boot_to_cd(enabled: enabled, mode: mode)
     end
     
-    def boot_to_usb(persistence: nil, mode: nil)
-      @supermicro_client.boot_to_usb(persistence: persistence, mode: mode)
+    def boot_to_usb(enabled: "Once", mode: nil)
+      @supermicro_client.boot_to_usb(enabled: enabled, mode: mode)
     end
     
-    def boot_to_bios_setup(persistence: nil, mode: nil)
-      @supermicro_client.boot_to_bios_setup(persistence: persistence, mode: mode)
+    def boot_to_bios_setup(enabled: "Once", mode: nil)
+      @supermicro_client.boot_to_bios_setup(enabled: enabled, mode: mode)
     end
     
     def configure_boot_settings(persistence: nil, mode: nil)
       @supermicro_client.configure_boot_settings(persistence: persistence, mode: mode)
     end
     
+    # PCI Devices
+    
+    def pci_devices
+      # Supermicro has limited PCI device support
+      # Try to get basic info from /redfish/v1/Chassis/1/PCIeDevices
+      begin
+        response = @supermicro_client.authenticated_request(:get, "/redfish/v1/Chassis/1/PCIeDevices")
+        
+        if response.status == 200
+          data = JSON.parse(response.body)
+          devices = []
+          
+          data["Members"].each do |member|
+            device_path = member["@odata.id"]
+            device_response = @supermicro_client.authenticated_request(:get, device_path)
+            
+            if device_response.status == 200
+              device_data = JSON.parse(device_response.body)
+              
+              devices << OpenStruct.new(
+                id: device_data["Id"],
+                name: device_data["Name"],
+                manufacturer: device_data["Manufacturer"],
+                model: device_data["Model"],
+                device_type: device_data["DeviceType"],
+                device_class: device_data["Description"]&.include?("NIC") ? "NetworkController" : "Unknown",
+                pcie_type: device_data.dig("PCIeInterface", "PCIeType"),
+                lanes: device_data.dig("PCIeInterface", "LanesInUse")
+              )
+            end
+          end
+          
+          return devices
+        end
+      rescue => e
+        # Silently fail and return empty array
+      end
+      
+      []
+    end
+    
+    def nics_with_pci_info
+      # Supermicro doesn't provide PCI slot mapping for NICs
+      # Return NICs without PCI info
+      nics = @supermicro_client.nics
+      nics.map { |nic| OpenStruct.new(nic) }
+    end
+    
     # Jobs
     
     def jobs
@@ -233,14 +476,54 @@ module Radfish
       @supermicro_client.cancel_job(job_id)
     end
     
-    def clear_completed_jobs
-      @supermicro_client.clear_completed_jobs
+    def clear_jobs!
+      @supermicro_client.clear_jobs!
     end
     
     def jobs_summary
       @supermicro_client.jobs_summary
     end
     
+    # BMC Management
+    
+    def ensure_vendor_specific_bmc_ready!
+      # For Supermicro, no specific action needed - BMC is always ready
+      # This is a no-op but returns true for consistency
+      true
+    end
+    
+    # BIOS Configuration
+    
+    def bios_error_prompt_disabled?
+      @supermicro_client.bios_error_prompt_disabled?
+    end
+    
+    def bios_hdd_placeholder_enabled?
+      @supermicro_client.bios_hdd_placeholder_enabled?
+    end
+    
+    def bios_os_power_control_enabled?
+      @supermicro_client.bios_os_power_control_enabled?
+    end
+    
+    def ensure_sensible_bios!(options = {})
+      @supermicro_client.ensure_sensible_bios!(options)
+    end
+    
+    def ensure_uefi_boot
+      @supermicro_client.ensure_uefi_boot
+    end
+    
+    def set_one_time_boot_to_virtual_media
+      # Use Supermicro's method for setting one-time boot to virtual media
+      @supermicro_client.set_one_time_boot_to_virtual_media
+    end
+    
+    def set_boot_order_hd_first
+      # Use Supermicro's method for setting boot order to HD first
+      @supermicro_client.set_boot_order_hd_first
+    end
+    
     # Utility
     
     def sel_log
@@ -283,6 +566,46 @@ module Radfish
       @supermicro_client.get_firmware_version
     end
     
+    def bmc_info
+      # Combine various BMC-related information into a single response
+      info = {}
+      
+      # Get firmware version
+      info[:firmware_version] = @supermicro_client.get_firmware_version
+      
+      # Get Redfish version from service info
+      service = @supermicro_client.service_info
+      info[:redfish_version] = service["RedfishVersion"] if service.is_a?(Hash)
+      
+      # Get license info
+      licenses = @supermicro_client.licenses
+      if licenses.is_a?(Array) && !licenses.empty?
+        # Look for the main BMC license
+        main_license = licenses.find { |l| l["LicenseClass"] == "BMC" } || licenses.first
+        info[:license_version] = main_license["LicenseVersion"] if main_license.is_a?(Hash)
+      end
+      
+      # Get network info for MAC and IP
+      network = @supermicro_client.get_bmc_network
+      if network.is_a?(Hash)
+        info[:mac_address] = network["mac"]
+        info[:ip_address] = network["ipv4"]
+        info[:hostname] = network["hostname"] || network["fqdn"]
+      end
+      
+      # Get health status from system info if available
+      system = @supermicro_client.system_info
+      info[:health] = system["Status"]["Health"] if system.is_a?(Hash) && system.dig("Status", "Health")
+      
+      info
+    end
+    
+    def system_health
+      # Convert hash to OpenStruct for dot notation access
+      health_data = @supermicro_client.system_health
+      OpenStruct.new(health_data)
+    end
+    
     # License management
     
     def check_virtual_media_license
@@ -314,6 +637,30 @@ module Radfish
     def manager_network_protocol
       @supermicro_client.manager_network_protocol if @supermicro_client.respond_to?(:manager_network_protocol)
     end
+    
+    # Network management
+    
+    def get_bmc_network
+      @supermicro_client.get_bmc_network
+    end
+    
+    def set_bmc_network(ipv4: nil, mask: nil, gateway: nil, 
+                        dns_primary: nil, dns_secondary: nil, hostname: nil, 
+                        dhcp: false)
+      @supermicro_client.set_bmc_network(
+        ipv4: ipv4,
+        mask: mask,
+        gateway: gateway,
+        dns_primary: dns_primary,
+        dns_secondary: dns_secondary,
+        hostname: hostname,
+        dhcp: dhcp
+      )
+    end
+    
+    def set_bmc_dhcp
+      @supermicro_client.set_bmc_dhcp
+    end
   end
   
   # Register the adapter

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: radfish-supermicro
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Jonathan Siegel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-28 00:00:00.000000000 Z
+date: 2025-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: radfish