radfish-idrac 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ca9aaace52a026497cd359cb588c3d5263246834b815f186fa5ab8fc2128f8
-  data.tar.gz: 8c7a0867b543a73eec9cebfc9a86367e4a6c9cbcd415ca09c59483f88a88d110
+  metadata.gz: bd2c3bf25651e2968b2bbb5646abfe3be4af7679d750f1f5d958a8440db7762a
+  data.tar.gz: e6235fd71297dc9ef3feea51d9d30e8ad80e645e4b37e8000a396be45fa628ec
 SHA512:
-  metadata.gz: 76bdaa10dd93e366ba582f6e9e06faca9faa6d722c9d425abb6ff209b7e7aad904ab1764050bdbad660eb34b6532902a943228dd96979c1b5d88fc2b780083ad
-  data.tar.gz: d7befbdcc8e1652e2b2b11fd3b2b086f6a0f3a65978873a5aec6688d7dd5f948bdc89df5d0109075991123d71b5b50d966f9ebd5c670e522e4642c060c493288
+  metadata.gz: c8a449130e8451cf9eacb9fc5cccbba1d8180ce874933488426b8ae1c589313a8ba6f725115351b40b2cf8c334869b6973c2d076231fe3347cbe96eed2727fb5
+  data.tar.gz: 8835042ad7199c7a88965099f2e5473101db5e5c7597ba09a195b1b790743aee2f2c2f7a1ba1110697094ac3dd8737154123e3c84f4bded61ea1f036c842888f

data/lib/radfish/idrac/version.rb

@@ -2,6 +2,6 @@
 
 module Radfish
   module Idrac
-    VERSION = "0.1.3"
+    VERSION = "0.1.5"
   end
 end

data/lib/radfish/idrac_adapter.rb

@@ -2,6 +2,7 @@
 
 require 'radfish'
 require 'idrac'
+require 'ostruct'
 
 module Radfish
   class IdracAdapter < Core::BaseClient
@@ -63,30 +64,95 @@ module Radfish
       @idrac_client.get_power_state
     end
     
-    def power_on
-      @idrac_client.power_on
-    end
-    
-    def power_off(force: false)
-      kind = force ? "ForceOff" : "GracefulShutdown"
-      @idrac_client.power_off(kind: kind)
+    def power_on(wait: true)
+      result = @idrac_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 = power_state
+            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_restart(force: false)
-      # iDRAC uses reboot method, which is ForceRestart by default
-      if force
-        @idrac_client.reboot
-      else
-        # Try graceful restart first
-        @idrac_client.power_off(kind: "GracefulRestart") rescue @idrac_client.reboot
+    def power_off(type: "GracefulShutdown", wait: true)
+      # Use the type parameter directly - it already uses Redfish standard values
+      result = @idrac_client.power_off(kind: type)
+      
+      if wait && result
+        # Wait for power off to complete
+        max_attempts = 30
+        attempts = 0
+        while attempts < max_attempts
+          sleep 2
+          begin
+            status = power_state
+            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 reboot(type: "GracefulRestart", wait: true)
+      # Use the type parameter - iDRAC's power_off can handle restart types
+      begin
+        result = @idrac_client.power_off(kind: type)
+      rescue => e
+        # If graceful restart fails, fall back to force restart
+        if type == "GracefulRestart"
+          debug "Graceful restart failed, using force restart", 1, :yellow
+          result = @idrac_client.reboot  # This is ForceRestart
+        else
+          raise e
+        end
+      end
+      
+      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 = power_state
+            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
-      # iDRAC doesn't have power_cycle, simulate with off then on
-      power_off
+    def power_cycle(wait: true)
+      # Power cycle: turn off then on
+      power_off(type: "ForceOff", wait: wait)
       sleep 5
-      power_on
+      power_on(wait: wait)
     end
     
     def reset_type_allowed
@@ -97,35 +163,123 @@ module Radfish
     # System information
     
     def system_info
-      @idrac_client.system_info
+      # iDRAC gem returns string keys, convert to symbols for radfish
+      info = @idrac_client.system_info
+      
+      # Dell servers always have "Dell Inc." as manufacturer
+      # Normalize for consistency
+      manufacturer = "Dell"
+      
+      model = info["model"]
+      model = model&.gsub(/^PowerEdge\s+/i, '') if model  # Strip PowerEdge prefix
+      
+      {
+        service_tag: info["service_tag"],
+        manufacturer: manufacturer,
+        make: manufacturer,
+        model: model,
+        serial: info["service_tag"],  # Dell uses service tag as serial
+        serial_number: info["service_tag"],
+        firmware_version: info["firmware_version"],
+        idrac_version: info["idrac_version"],
+        is_dell: info["is_dell"]
+      }.compact
+    end
+    
+    # Individual accessor methods for Core::System interface
+    def service_tag
+      @service_tag ||= @idrac_client.system_info["service_tag"]
+    end
+    
+    def make
+      "Dell"
+    end
+    
+    def model
+      @model ||= begin
+        model = @idrac_client.system_info["model"]
+        model&.gsub(/^PowerEdge\s+/i, '') if model  # Strip PowerEdge prefix
+      end
+    end
+    
+    def serial
+      @serial ||= @idrac_client.system_info["service_tag"]  # Dell uses service tag as serial
     end
     
     def cpus
-      @idrac_client.cpus
+      # The idrac gem returns a summary hash, but radfish expects an array of CPU objects
+      # For Dell servers, typically all CPUs are identical, so we create objects based on the summary
+      cpu_summary = @idrac_client.cpus
+      
+      # Create CPU objects that support dot notation
+      count = cpu_summary["count"] || 0
+      return [] if count == 0
+      
+      # For each CPU socket, create an object
+      # Dell typically has identical CPUs, so we use the summary data for each
+      (1..count).map do |socket_num|
+        OpenStruct.new(
+          socket: socket_num,
+          manufacturer: "Intel", # Dell servers typically use Intel
+          model: cpu_summary["model"],
+          speed_mhz: nil, # Not provided in summary
+          cores: cpu_summary["cores"] ? (cpu_summary["cores"] / count) : nil,
+          threads: cpu_summary["threads"] ? (cpu_summary["threads"] / count) : nil,
+          health: cpu_summary["status"]
+        )
+      end
     end
     
     def memory
-      @idrac_client.memory
+      mem_data = @idrac_client.memory
+      return [] unless mem_data
+      
+      # Convert to OpenStruct for dot notation access
+      mem_data.map { |m| OpenStruct.new(m) }
     end
     
     def nics
-      @idrac_client.nics
+      nic_data = @idrac_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
-      @idrac_client.fans
+      # Convert hash array to OpenStruct objects for dot notation access
+      fan_data = @idrac_client.fans
+      
+      fan_data.map do |fan|
+        OpenStruct.new(fan)
+      end
     end
     
     def temperatures
-      @idrac_client.temperatures
+      # iDRAC doesn't provide a dedicated temperatures method
+      # Return empty array to satisfy the interface
+      []
     end
     
     def psus
-      @idrac_client.psus
+      # Convert hash array to OpenStruct objects for dot notation access
+      psu_data = @idrac_client.psus
+      
+      psu_data.map do |psu|
+        OpenStruct.new(psu)
+      end
     end
     
     def power_consumption
-      @idrac_client.power_consumption
+      # Return a hash with power consumption data for radfish
+      {
+        consumed_watts: @idrac_client.get_power_usage_watts
+      }
     end
     
     def power_consumption_watts
@@ -135,19 +289,69 @@ module Radfish
     # Storage
     
     def storage_controllers
-      @idrac_client.storage_controllers
+      # Convert hash array to OpenStruct objects for dot notation access
+      # Note: idrac gem uses 'controllers' not 'storage_controllers'
+      controller_data = @idrac_client.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
-      @idrac_client.drives
+    def drives(controller_id)
+      # The iDRAC gem requires a controller_id
+      raise ArgumentError, "Controller ID is required" unless controller_id
+      
+      drive_data = @idrac_client.drives(controller_id)
+      
+      # Convert to OpenStruct for consistency
+      drive_data.map { |drive| OpenStruct.new(drive) }
     end
     
-    def volumes
-      @idrac_client.volumes
+    def volumes(controller_id)
+      # The iDRAC gem requires a controller_id
+      raise ArgumentError, "Controller ID is required" unless controller_id
+      
+      volume_data = @idrac_client.volumes(controller_id)
+      
+      # Convert to OpenStruct for consistency
+      volume_data.map { |volume| OpenStruct.new(volume) }
     end
     
     def storage_summary
-      @idrac_client.storage_summary
+      # The iDRAC gem doesn't have a storage_summary method
+      # We need to build it from controllers, drives, and volumes
+      begin
+        controllers = @idrac_client.controllers
+        total_drives = 0
+        total_volumes = 0
+        
+        controllers.each do |controller|
+          if controller["@odata.id"]
+            drives = @idrac_client.drives(controller["@odata.id"]) rescue []
+            volumes = @idrac_client.volumes(controller["@odata.id"]) rescue []
+            total_drives += drives.size
+            total_volumes += volumes.size
+          end
+        end
+        
+        {
+          "controller_count" => controllers.size,
+          "drive_count" => total_drives,
+          "volume_count" => total_volumes
+        }
+      rescue => e
+        puts "Error fetching storage summary: #{e.message}" if @debug
+        {
+          "controller_count" => 0,
+          "drive_count" => 0,
+          "volume_count" => 0
+        }
+      end
     end
     
     # Virtual Media
@@ -156,12 +360,41 @@ module Radfish
       @idrac_client.virtual_media
     end
     
-    def insert_virtual_media(iso_url, device: "CD")
+    def insert_virtual_media(iso_url, device: nil)
+      # Default to "CD" for iDRAC if not specified
+      device ||= "CD"
       @idrac_client.insert_virtual_media(iso_url, device: device)
+    rescue Idrac::Error => e
+      # Translate iDRAC errors to Radfish errors with context
+      error_message = e.message
+      
+      if error_message.include?("connection refused") || error_message.include?("unreachable")
+        raise Radfish::VirtualMediaConnectionError, "BMC cannot reach ISO server: #{error_message}"
+      elsif error_message.include?("already attached") || error_message.include?("in use")
+        raise Radfish::VirtualMediaBusyError, "Virtual media device busy: #{error_message}"
+      elsif error_message.include?("not found") || error_message.include?("does not exist")
+        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
+    rescue StandardError => e
+      # Catch any other errors and wrap them
+      raise Radfish::VirtualMediaError, "Virtual media insertion failed: #{e.message}"
     end
     
     def eject_virtual_media(device: "CD")
       @idrac_client.eject_virtual_media(device: device)
+    rescue Idrac::Error => e
+      if e.message.include?("not found") || e.message.include?("does not exist")
+        raise Radfish::VirtualMediaNotFoundError, "Virtual media device not found: #{e.message}"
+      else
+        raise Radfish::VirtualMediaError, "Failed to eject virtual media: #{e.message}"
+      end
+    rescue StandardError => e
+      raise Radfish::VirtualMediaError, "Failed to eject virtual media: #{e.message}"
     end
     
     def virtual_media_status
@@ -188,12 +421,24 @@ module Radfish
     
     # Boot configuration
     
+    def boot_config
+      # Return hash for consistent data structure
+      @idrac_client.boot_config
+    end
+    
+    # Shorter alias for convenience
+    def boot
+      boot_config
+    end
+    
     def boot_options
-      @idrac_client.boot_options
+      # Return array of OpenStructs for boot options
+      options = @idrac_client.boot_options
+      options.map { |opt| OpenStruct.new(opt) }
     end
     
-    def set_boot_override(target, persistent: false)
-      @idrac_client.set_boot_override(target, persistent: persistent)
+    def set_boot_override(target, enabled: "Once", mode: nil)
+      @idrac_client.set_boot_override(target, enabled: enabled, mode: mode)
     end
     
     def clear_boot_override
@@ -208,24 +453,45 @@ module Radfish
       @idrac_client.get_boot_devices
     end
     
-    def boot_to_pxe
-      @idrac_client.boot_to_pxe
+    def boot_to_pxe(enabled: "Once", mode: nil)
+      @idrac_client.boot_to_pxe(enabled: enabled, mode: mode)
+    end
+    
+    def boot_to_disk(enabled: "Once", mode: nil)
+      @idrac_client.boot_to_disk(enabled: enabled, mode: mode)
     end
     
-    def boot_to_disk
-      @idrac_client.boot_to_disk
+    def boot_to_cd(enabled: "Once", mode: nil)
+      @idrac_client.boot_to_cd(enabled: enabled, mode: mode)
     end
     
-    def boot_to_cd
-      @idrac_client.boot_to_cd
+    def boot_to_usb(enabled: "Once", mode: nil)
+      @idrac_client.boot_to_usb(enabled: enabled, mode: mode)
     end
     
-    def boot_to_usb
-      @idrac_client.boot_to_usb
+    def boot_to_bios_setup(enabled: "Once", mode: nil)
+      @idrac_client.boot_to_bios_setup(enabled: enabled, mode: mode)
+    end
+    
+    # PCI Devices
+    
+    def pci_devices
+      devices = @idrac_client.pci_devices
+      return [] unless devices
+      
+      # Convert to OpenStruct for dot notation access
+      devices.map { |device| OpenStruct.new(device) }
     end
     
-    def boot_to_bios_setup
-      @idrac_client.boot_to_bios_setup
+    def nics_with_pci_info
+      nics = @idrac_client.nics
+      pci = pci_devices
+      
+      # Use the existing nics_to_pci method from idrac gem
+      nics_with_pci = @idrac_client.nics_to_pci(nics, pci.map(&:to_h))
+      
+      # Convert to OpenStruct
+      nics_with_pci.map { |nic| OpenStruct.new(nic) }
     end
     
     # Jobs
@@ -246,14 +512,112 @@ module Radfish
       @idrac_client.cancel_job(job_id)
     end
     
-    def clear_completed_jobs
-      @idrac_client.clear_jobs
+    def clear_jobs!
+      @idrac_client.clear_jobs!
     end
     
     def jobs_summary
       jobs
     end
     
+    # BMC Management
+    
+    def ensure_vendor_specific_bmc_ready!
+      # For iDRAC, ensure the Lifecycle Controller is enabled
+      @idrac_client.ensure_lifecycle_controller!
+    end
+    
+    # BIOS Configuration
+    
+    def bios_error_prompt_disabled?
+      @idrac_client.bios_error_prompt_disabled?
+    end
+    
+    def bios_hdd_placeholder_enabled?
+      @idrac_client.bios_hdd_placeholder_enabled?
+    end
+    
+    def bios_os_power_control_enabled?
+      @idrac_client.bios_os_power_control_enabled?
+    end
+    
+    def ensure_uefi_boot
+      @idrac_client.ensure_uefi_boot
+    end
+    
+    def set_one_time_boot_to_virtual_media
+      # Use iDRAC's existing method for setting one-time boot to virtual media
+      @idrac_client.set_one_time_virtual_media_boot
+    end
+    
+    def set_boot_order_hd_first
+      # Use iDRAC's existing method for setting boot order to HD first
+      @idrac_client.set_boot_order_hd_first
+    end
+    
+    def ensure_sensible_bios!(options = {})
+      # Check current state
+      if bios_error_prompt_disabled? && 
+         bios_hdd_placeholder_enabled? && 
+         bios_os_power_control_enabled?
+        puts "BIOS settings already configured correctly".green
+        return { changes_made: false }
+      end
+      
+      puts "Configuring BIOS settings...".yellow
+      
+      # Build the System Configuration Profile (SCP)
+      scp = {}
+      
+      # Disable error prompt (don't halt on errors)
+      if !bios_error_prompt_disabled?
+        scp = @idrac_client.merge_scp(scp, {
+          "BIOS.Setup.1-1" => {
+            "ErrPrompt" => "Disabled"
+          }
+        })
+      end
+      
+      # Enable HDD placeholder for boot order control
+      if !bios_hdd_placeholder_enabled?
+        scp = @idrac_client.merge_scp(scp, {
+          "BIOS.Setup.1-1" => {
+            "HddPlaceholder" => "Enabled"
+          }
+        })
+      end
+      
+      # Enable OS power control
+      if !bios_os_power_control_enabled?
+        scp = @idrac_client.merge_scp(scp, {
+          "BIOS.Setup.1-1" => {
+            "ProcCStates" => "Enabled",
+            "SysProfile" => "PerfPerWattOptimizedOs",
+            "ProcPwrPerf" => "OsDbpm"
+          }
+        })
+      end
+      
+      # Set UEFI boot mode
+      scp = @idrac_client.merge_scp(scp, {
+        "BIOS.Setup.1-1" => {
+          "BootMode" => "Uefi"
+        }
+      })
+      
+      # Disable host header check for better compatibility
+      scp = @idrac_client.merge_scp(scp, {
+        "iDRAC.Embedded.1" => {
+          "WebServer.1#HostHeaderCheck" => "Disabled"
+        }
+      })
+      
+      # Apply the configuration
+      @idrac_client.set_system_configuration_profile(scp)
+      
+      { changes_made: true }
+    end
+    
     # Utility
     
     def sel_log
@@ -296,18 +660,50 @@ module Radfish
       @idrac_client.get_firmware_version
     end
     
-    # Additional iDRAC-specific methods
+    def bmc_info
+      # Map iDRAC gem data to radfish format
+      info = {}
+      
+      # Get firmware version from idrac gem
+      info[:firmware_version] = @idrac_client.get_firmware_version
+      
+      # Get iDRAC generation (7/8/9) from idrac gem's license_version method
+      info[:license_version] = @idrac_client.license_version&.to_s
+      
+      # Get Redfish version from idrac gem
+      info[:redfish_version] = @idrac_client.redfish_version
+      
+      # Get network info for MAC and IP
+      network = @idrac_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
+      system = @idrac_client.system_info
+      if system.is_a?(Hash)
+        info[:health] = system.dig("Status", "Health") || system.dig("Status", "HealthRollup")
+      end
+      
+      info
+    end
     
-    def screenshot
-      @idrac_client.screenshot if @idrac_client.respond_to?(:screenshot)
+    def system_health
+      # Convert hash to OpenStruct for dot notation access
+      health_data = @idrac_client.system_health
+      OpenStruct.new(health_data)
     end
     
-    def licenses
-      @idrac_client.licenses if @idrac_client.respond_to?(:licenses)
+    # Additional iDRAC-specific methods
+    
+    def screenshot
+      @idrac_client.screenshot
     end
     
     def license_info
-      @idrac_client.license_info if @idrac_client.respond_to?(:license_info)
+      @idrac_client.license_info
     end
     
     # Network management
@@ -316,12 +712,12 @@ module Radfish
       @idrac_client.get_bmc_network
     end
     
-    def set_bmc_network(ip_address: nil, subnet_mask: nil, gateway: nil, 
+    def set_bmc_network(ipv4: nil, mask: nil, gateway: nil, 
                         dns_primary: nil, dns_secondary: nil, hostname: nil, 
                         dhcp: false)
       @idrac_client.set_bmc_network(
-        ip_address: ip_address,
-        subnet_mask: subnet_mask,
+        ipv4: ipv4,
+        mask: mask,
         gateway: gateway,
         dns_primary: dns_primary,
         dns_secondary: dns_secondary,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: radfish-idrac
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 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
@@ -85,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Dell iDRAC adapter for Radfish