idrac 0.8.2 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f05569a76e03f75c446229de12ff12a84b6d93a23256821e3fba8c43e2241a49
-  data.tar.gz: 25de5109e5e40914d50d7ded48a2e83fb42f93f1fe1a3fa1b83fdd307fe15c58
+  metadata.gz: 6f2dd002b1876905499180d33abb476ed732f945aef7df82ed55bc68887763fd
+  data.tar.gz: a6a90ac44186a45ca043af595a2797d992d998b9da1a75a2d569c1ea2c7f0c1e
 SHA512:
-  metadata.gz: d28f789451cddfaa2fbd31a24109f6a7517b4605a1604c70c37bba5cc9b73d10bd3f187fcdc5e934d55c06c966bcc7cacbad615ffadca6fb873d6e03af0284bf
-  data.tar.gz: 22b385944dd4abb637bdfea5f3383f9b853d6bd37ffa889fde70482802da163cdd20ef1f7580e7c54657aa900fbf9cbb8ef8e7199fcd0f4d4a985617f574c158
+  metadata.gz: a75656b84dcc40e9fb80b65787dde092b71391cdb7d680c847cadd77394dc00c4081a772ed742d4ad758a4e075e1a00ef4a01ef2571a8901fa1347b176e1d578
+  data.tar.gz: ac5962c3858f449c433cc9b76ad61bc72f316af028796ab04f363ce0f3cfd786ff3903fd7e09e07f220d5a7d40d45c4d591246eabcc31648a4071a2d27245241

data/bin/idrac-tsr

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/idrac'
+require 'optparse'
+
+options = {
+  host: ENV['IDRAC_HOST'],
+  username: ENV['IDRAC_USER'] || 'root',
+  password: ENV['IDRAC_PASSWORD'] || 'calvin',
+  output: nil,
+  data_types: [0, 1, 2], # Default: Hardware, OS, Debug
+  timeout: 600,
+  verbose: false
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: idrac-tsr [options]"
+  
+  opts.on("-h", "--host HOST", "iDRAC host address") do |h|
+    options[:host] = h
+  end
+  
+  opts.on("-u", "--username USER", "Username (default: root)") do |u|
+    options[:username] = u
+  end
+  
+  opts.on("-p", "--password PASS", "Password (default: calvin)") do |p|
+    options[:password] = p
+  end
+  
+  opts.on("-o", "--output FILE", "Output filename (default: auto-generated)") do |o|
+    options[:output] = o
+  end
+  
+  opts.on("-d", "--data TYPES", "Data types to collect (comma-separated: 0=HW,1=OS,2=Debug,3=TTY,4=All)") do |d|
+    options[:data_types] = d.split(',').map(&:to_i)
+  end
+  
+  opts.on("-t", "--timeout SECONDS", Integer, "Timeout in seconds (default: 600)") do |t|
+    options[:timeout] = t
+  end
+  
+  opts.on("-v", "--verbose", "Verbose output") do
+    options[:verbose] = true
+  end
+  
+  opts.on("--help", "Show this message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+if options[:host].nil?
+  puts "Error: Host is required. Use -h HOST or set IDRAC_HOST environment variable"
+  exit 1
+end
+
+begin
+  client = IDRAC::Client.new(
+    host: options[:host],
+    username: options[:username],
+    password: options[:password],
+    verify_ssl: false
+  )
+  
+  client.verbosity = options[:verbose] ? 1 : 0
+  
+  puts "Connecting to #{options[:host]}..."
+  client.login
+  
+  puts "Generating TSR logs (this may take several minutes)..."
+  result = client.generate_and_download_tsr(
+    output_file: options[:output],
+    data_selector_values: options[:data_types],
+    wait_timeout: options[:timeout]
+  )
+  
+  if result
+    puts "✓ TSR logs saved to: #{result}"
+    puts "  File size: #{File.size(result) / 1024 / 1024} MB" if File.exist?(result)
+  else
+    puts "✗ Failed to download TSR logs"
+    exit 1
+  end
+  
+  client.logout
+rescue => e
+  puts "Error: #{e.message}"
+  exit 1
+end

data/lib/idrac/boot.rb

@@ -28,8 +28,229 @@ require 'colorize'
 # https://github.com/dell/iDRAC-Redfish-Scripting/issues/116
 module IDRAC
   module Boot
-    # Get BIOS boot options
+    # Get boot configuration with snake_case fields
+    def boot_config
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.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
+          
+          # 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 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: "Boot0001", name: "Ubuntu"}]
+            "boot_order_refs" => boot_data["BootOrder"] || [],                            # Raw references for set_boot_order
+            
+            # UEFI specific fields
+            "uefi_target_boot_source_override" => boot_data["UefiTargetBootSourceOverride"],
+            "stop_boot_on_fault" => boot_data["StopBootOnFault"],
+            
+            # References to other resources
+            "boot_options_uri" => boot_data.dig("BootOptions", "@odata.id"),
+            "certificates_uri" => boot_data.dig("Certificates", "@odata.id")
+          }.compact
+        rescue JSON::ParserError
+          raise Error, "Failed to parse boot response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get boot configuration. Status code: #{response.status}"
+      end
+    end
+    
+    # Get raw Redfish boot data (CamelCase)
+    def boot_raw
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1")
+      
+      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
+    
+    # Get boot options collection - the actual boot devices present in the system
+    # This is different from boot_config which returns the boot configuration settings
+    def boot_options
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/BootOptions?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          # Return the BootOption objects with snake_case
+          data["Members"]&.map do |member|
+            {
+              "id" => member["Id"],                                           # Boot0001
+              "boot_option_reference" => member["BootOptionReference"],       # Boot0001  
+              "display_name" => member["DisplayName"],                        # "Integrated RAID Controller 1: Ubuntu"
+              "name" => member["DisplayName"] || member["Name"],              # Alias for display_name
+              "enabled" => member["BootOptionEnabled"],                       # true/false
+              "uefi_device_path" => member["UefiDevicePath"],                 # UEFI device path
+              "description" => member["Description"]
+            }.compact
+          end || []
+        rescue JSON::ParserError
+          raise Error, "Failed to parse boot options response: #{response.body}"
+        end
+      else
+        []
+      end
+    end
+    
+    # Legacy method names for backward compatibility
     def get_bios_boot_options
+      get_bios_boot_sources
+    end
+    
+    def get_boot_devices
+      boot_options
+    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"]
+      
+      if valid_targets && !valid_targets.include?(target)
+        debug "Invalid boot target '#{target}'. Allowed values: #{valid_targets.join(', ')}", 1, :red
+        raise Error, "Invalid boot target: #{target}"
+      end
+      
+      debug "Setting boot override to #{target} (#{enabled})...", 1, :yellow
+      
+      body = {
+        "Boot" => {
+          "BootSourceOverrideEnabled" => enabled,  # Disabled/Once/Continuous
+          "BootSourceOverrideTarget" => target     # None/Pxe/Hdd/Cd/etc
+        }
+      }
+      
+      # Add boot mode if specified
+      body["Boot"]["BootSourceOverrideMode"] = mode if mode
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Systems/System.Embedded.1",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "Boot override set successfully.", 1, :green
+        return true
+      else
+        raise Error, "Failed to set boot override: #{response.status} - #{response.body}"
+      end
+    end
+    
+    # Clear boot override settings
+    def clear_boot_override
+      debug "Clearing boot override...", 1, :yellow
+      
+      body = {
+        "Boot" => {
+          "BootSourceOverrideEnabled" => "Disabled"
+        }
+      }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Systems/System.Embedded.1",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "Boot override cleared successfully.", 1, :green
+        return true
+      else
+        raise Error, "Failed to clear boot override: #{response.status} - #{response.body}"
+      end
+    end
+    
+    # Set the permanent boot order
+    def set_boot_order(devices)
+      debug "Setting boot order...", 1, :yellow
+      
+      body = {
+        "Boot" => {
+          "BootOrder" => devices
+        }
+      }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Systems/System.Embedded.1",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "Boot order set successfully.", 1, :green
+        return true
+      else
+        raise Error, "Failed to set boot order: #{response.status} - #{response.body}"
+      end
+    end
+    
+    # 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(enabled: "Once", mode: nil)
+      set_boot_override("Hdd", enabled: enabled, mode: mode)
+    end
+    
+    def boot_to_cd(enabled: "Once", mode: nil)
+      set_boot_override("Cd", enabled: enabled, mode: mode)
+    end
+    
+    def boot_to_usb(enabled: "Once", mode: nil)
+      set_boot_override("Usb", enabled: enabled, mode: mode)
+    end
+    
+    def boot_to_bios_setup(enabled: "Once", mode: nil)
+      set_boot_override("BiosSetup", enabled: enabled, mode: mode)
+    end
+    
+    private
+    
+    def get_bios_boot_sources
       response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/BootSources")
       
       if response.status == 200
@@ -62,6 +283,8 @@ module IDRAC
       end
     end
     
+    public
+    
     # Ensure UEFI boot mode
     def ensure_uefi_boot
       response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/Bios")

data/lib/idrac/client.rb

@@ -23,6 +23,7 @@ module IDRAC
     include License
     include SystemConfig
     include Utility
+    include Network
 
     def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: false, direct_mode: false, retry_count: 3, retry_delay: 1, host_header: nil)
       @host = host

data/lib/idrac/jobs.rb

@@ -42,33 +42,30 @@ module IDRAC
     
     # Clear all jobs from the job queue
     def clear_jobs!
-      # Get list of jobs
       jobs_response = authenticated_request(:get, '/redfish/v1/Managers/iDRAC.Embedded.1/Jobs?$expand=*($levels=1)')
-      handle_response(jobs_response)
+      return true unless jobs_response.status == 200
       
-      if jobs_response.status == 200
-        begin
-          jobs_data = JSON.parse(jobs_response.body)
-          members = jobs_data["Members"]
-          
-          # Delete each job individually
-          members.each.with_index do |job, i|
-            puts "Removing #{job['Id']} : #{job['JobState']} > #{job['Message']} [#{i+1}/#{members.count}]".yellow
-            delete_response = authenticated_request(:delete, "/redfish/v1/Managers/iDRAC.Embedded.1/Jobs/#{job['Id']}")
-            
-            unless delete_response.status.between?(200, 299)
-              puts "Warning: Failed to delete job #{job['Id']}. Status code: #{delete_response.status}".yellow
-            end
-          end
-          
-          puts "Successfully cleared all jobs".green
-          return true
-        rescue JSON::ParserError
-          raise Error, "Failed to parse jobs response: #{jobs_response.body}"
+      jobs_data = JSON.parse(jobs_response.body)
+      members = jobs_data["Members"] || []
+      
+      if members.empty?
+        puts "No jobs to clear.".yellow
+        return true
+      end
+      
+      puts "Clearing #{members.length} jobs...".yellow
+      
+      members.each_with_index do |job, i|
+        puts "Removing #{job['Id']} : #{job['JobState']} > #{job['Message']} [#{i+1}/#{members.count}]".yellow
+        response = authenticated_request(:delete, "/redfish/v1/Managers/iDRAC.Embedded.1/Jobs/#{job['Id']}")
+        
+        unless response.status.between?(200, 299)
+          puts "Warning: Failed to delete job #{job['Id']}. Status code: #{response.status}".yellow
         end
-      else
-        raise Error, "Failed to get jobs. Status code: #{jobs_response.status}"
       end
+      
+      puts "Successfully cleared all jobs".green
+      true
     end
     
     # Force clear the job queue

data/lib/idrac/network.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module IDRAC
+  module Network
+    def get_bmc_network
+      # Get the iDRAC ethernet interface
+      collection_response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/EthernetInterfaces")
+      
+      if collection_response.status == 200
+        collection = JSON.parse(collection_response.body)
+        
+        if collection["Members"] && collection["Members"].any?
+          interface_path = collection["Members"][0]["@odata.id"]
+          response = authenticated_request(:get, interface_path)
+          
+          if response.status == 200
+            data = JSON.parse(response.body)
+            {
+              "ipv4" => data.dig("IPv4Addresses", 0, "Address"),
+              "mask" => data.dig("IPv4Addresses", 0, "SubnetMask"),
+              "gateway" => data.dig("IPv4Addresses", 0, "Gateway"),
+              "mode" => data.dig("IPv4Addresses", 0, "AddressOrigin"), # DHCP or Static
+              "mac" => data["MACAddress"],
+              "hostname" => data["HostName"],
+              "fqdn" => data["FQDN"],
+              "dns_servers" => data["NameServers"] || [],
+              "name" => data["Id"] || "iDRAC",
+              "speed_mbps" => data["SpeedMbps"] || 1000,
+              "status" => data.dig("Status", "Health") || "OK",
+              "kind" => "ethernet"
+            }
+          else
+            raise Error, "Failed to get interface details. Status: #{response.status}"
+          end
+        else
+          raise Error, "No ethernet interfaces found"
+        end
+      else
+        raise Error, "Failed to get ethernet interfaces. Status: #{collection_response.status}"
+      end
+    end
+    
+    def set_bmc_network(ipv4: nil, mask: nil, gateway: nil, 
+                        dns_primary: nil, dns_secondary: nil, hostname: nil, 
+                        dhcp: false)
+      # Get the interface path first
+      collection_response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/EthernetInterfaces")
+      
+      if collection_response.status == 200
+        collection = JSON.parse(collection_response.body)
+        
+        if collection["Members"] && collection["Members"].any?
+          interface_path = collection["Members"][0]["@odata.id"]
+          
+          if dhcp
+            puts "Setting iDRAC to DHCP mode...".yellow
+            body = {
+              "DHCPv4" => {
+                "DHCPEnabled" => true
+              },
+              "IPv4Addresses" => [{
+                "AddressOrigin" => "DHCP"
+              }]
+            }
+          else
+            puts "Configuring iDRAC network settings...".yellow
+            body = {}
+            
+            # Configure static IP if provided
+            if ipv4 && mask
+              body["IPv4Addresses"] = [{
+                "Address" => ipv4,
+                "SubnetMask" => mask,
+                "Gateway" => gateway,
+                "AddressOrigin" => "Static"
+              }]
+              puts "  IP: #{ipv4}/#{mask}".cyan
+              puts "  Gateway: #{gateway}".cyan if gateway
+            end
+            
+            # Configure DNS if provided
+            if dns_primary || dns_secondary
+              dns_servers = []
+              dns_servers << dns_primary if dns_primary
+              dns_servers << dns_secondary if dns_secondary
+              body["StaticNameServers"] = dns_servers
+              puts "  DNS: #{dns_servers.join(', ')}".cyan
+            end
+            
+            # Configure hostname if provided
+            if hostname
+              body["HostName"] = hostname
+              puts "  Hostname: #{hostname}".cyan
+            end
+          end
+          
+          response = authenticated_request(
+            :patch,
+            interface_path,
+            body: body.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          )
+          
+          if response.status.between?(200, 299)
+            puts "iDRAC network configured successfully.".green
+            puts "WARNING: iDRAC may restart network services. Connection may be lost.".yellow if ip_address
+            true
+          else
+            raise Error, "Failed to configure iDRAC network: #{response.status} - #{response.body}"
+          end
+        else
+          raise Error, "No ethernet interfaces found"
+        end
+      else
+        raise Error, "Failed to get ethernet interfaces"
+      end
+    end
+    
+    def set_bmc_dhcp
+      # Convenience method
+      set_bmc_network(dhcp: true)
+    end
+  end
+end

data/lib/idrac/storage.rb

@@ -13,7 +13,8 @@ module IDRAC
           
           # Transform and return all controllers as an array of hashes with string keys
           controllers = data["Members"].map do |controller|
-            {
+            controller_data = {
+              "id" => controller["Id"],
               "name" => controller["Name"],
               "model" => controller["Model"],
               "drives_count" => controller["Drives"].size,
@@ -23,9 +24,21 @@ module IDRAC
               "encryption_capability" => controller.dig("Oem", "Dell", "DellController", "EncryptionCapability"),
               "controller_type" => controller.dig("Oem", "Dell", "DellController", "ControllerType"),
               "pci_slot" => controller.dig("Oem", "Dell", "DellController", "PCISlot"),
-              "raw" => controller,
-              "@odata.id" => controller["@odata.id"]
+              "@odata.id" => controller["@odata.id"],
+              # Store full controller data for access to all fields
+              "Oem" => controller["Oem"],
+              "Status" => controller["Status"],
+              "StorageControllers" => controller["StorageControllers"]
             }
+            
+            # Fetch drives for this controller
+            if controller["Drives"] && !controller["Drives"].empty?
+              controller_data["drives"] = fetch_controller_drives(controller["@odata.id"])
+            else
+              controller_data["drives"] = []
+            end
+            
+            controller_data
           end
           
           return controllers.sort_by { |c| c["name"] }
@@ -36,6 +49,56 @@ module IDRAC
         raise Error, "Failed to get controllers. Status code: #{response.status}"
       end
     end
+    
+    private
+    
+    def fetch_controller_drives(controller_id)
+      controller_path = controller_id.split("v1/").last
+      response = authenticated_request(:get, "/redfish/v1/#{controller_path}?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          drives = data["Drives"].map do |body|
+            serial = body["SerialNumber"] 
+            serial = body["Identifiers"].first["DurableName"] if serial.blank?
+            {
+              "id" => body["Id"],
+              "name" => body["Name"],
+              "serial" => serial,
+              "manufacturer" => body["Manufacturer"],
+              "model" => body["Model"],
+              "revision" => body["Revision"],
+              "capacity_bytes" => body["CapacityBytes"],
+              "speed_gbps" => body["CapableSpeedGbs"],
+              "rotation_speed_rpm" => body["RotationSpeedRPM"],
+              "media_type" => body["MediaType"],
+              "protocol" => body["Protocol"],
+              "health" => body.dig("Status", "Health") || "N/A",
+              "temperature_celsius" => nil,  # Not available in standard iDRAC
+              "failure_predicted" => body["FailurePredicted"],
+              "life_left_percent" => body["PredictedMediaLifeLeftPercent"],
+              # Dell-specific fields
+              "certified" => body.dig("Oem", "Dell", "DellPhysicalDisk", "Certified"),
+              "raid_status" => body.dig("Oem", "Dell", "DellPhysicalDisk", "RaidStatus"),
+              "operation_name" => body.dig("Oem", "Dell", "DellPhysicalDisk", "OperationName"),
+              "operation_progress" => body.dig("Oem", "Dell", "DellPhysicalDisk", "OperationPercentCompletePercent"),
+              "encryption_ability" => body["EncryptionAbility"],
+              "odata_id" => body["@odata.id"]  # Full API path for operations
+            }
+          end
+          
+          return drives.sort_by { |d| d["name"] }
+        rescue JSON::ParserError
+          []
+        end
+      else
+        []
+      end
+    end
+    
+    public
 
     # Find the best controller based on preference flags
     # @param name_pattern [String] Regex pattern to match controller name (defaults to "PERC")
@@ -108,22 +171,28 @@ module IDRAC
             serial = body["SerialNumber"] 
             serial = body["Identifiers"].first["DurableName"] if serial.blank?
             {
+              "id" => body["Id"],
+              "name" => body["Name"],
               "serial" => serial,
+              "manufacturer" => body["Manufacturer"],
               "model" => body["Model"],
-              "name" => body["Name"],
+              "revision" => body["Revision"],
               "capacity_bytes" => body["CapacityBytes"],
-              "health" => body.dig("Status", "Health") || "N/A",
-              "speed_gbp" => body["CapableSpeedGbs"],
-              "manufacturer" => body["Manufacturer"],
+              "speed_gbps" => body["CapableSpeedGbs"],
+              "rotation_speed_rpm" => body["RotationSpeedRPM"],
               "media_type" => body["MediaType"],
+              "protocol" => body["Protocol"],
+              "health" => body.dig("Status", "Health") || "N/A",
+              "temperature_celsius" => nil,  # Not available in standard iDRAC
               "failure_predicted" => body["FailurePredicted"],
               "life_left_percent" => body["PredictedMediaLifeLeftPercent"],
+              # Dell-specific fields
               "certified" => body.dig("Oem", "Dell", "DellPhysicalDisk", "Certified"),
               "raid_status" => body.dig("Oem", "Dell", "DellPhysicalDisk", "RaidStatus"),
               "operation_name" => body.dig("Oem", "Dell", "DellPhysicalDisk", "OperationName"),
               "operation_progress" => body.dig("Oem", "Dell", "DellPhysicalDisk", "OperationPercentCompletePercent"),
               "encryption_ability" => body["EncryptionAbility"],
-              "@odata.id" => body["@odata.id"]
+              "odata_id" => body["@odata.id"]  # Full API path for operations
             }
           end
           

data/lib/idrac/system.rb

@@ -16,7 +16,7 @@ module IDRAC
             bank, index = /DIMM ([A-Z])(\d+)/.match(dimm_name).captures
             
             {
-              "model" => m["Model"], 
+              "manufacturer" => m["Manufacturer"],
               "name" => m["Name"], 
               "capacity_bytes" => m["CapacityMiB"].to_i * 1024 * 1024, 
               "health" => m.dig("Status","Health") || "N/A", 
@@ -24,7 +24,9 @@ module IDRAC
               "part_number" => m["PartNumber"], 
               "serial" => m["SerialNumber"],
               "bank" => bank,
-              "index" => index.to_i
+              "index" => index.to_i,
+              "memory_device_type" => m["MemoryDeviceType"],
+              "base_module_type" => m["BaseModuleType"]
             }
           end
           
@@ -87,7 +89,8 @@ module IDRAC
                 "name" => fan["Name"], 
                 "rpm" => fan["Reading"],
                 "serial" => fan["SerialNumber"],
-                "status" => fan.dig("Status", "Health")
+                "status" => fan.dig("Status", "Health"),
+                "state" => fan.dig("Status", "State")
               }
             end
             
@@ -646,7 +649,7 @@ module IDRAC
           data = JSON.parse(response.body)
           
           health = {
-            "overall" => data.dig("Status", "HealthRollup"),
+            "rollup" => data.dig("Status", "HealthRollup"),
             "system" => data.dig("Status", "Health"),
             "processor" => data.dig("ProcessorSummary", "Status", "Health"),
             "memory" => data.dig("MemorySummary", "Status", "Health"),
@@ -666,17 +669,29 @@ module IDRAC
     def system_event_logs
       response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/Logs/Sel?$expand=*($levels=1)")
       
-      if response.status == 200
+      if response.status == 404
+        debug "SEL log not available on this system", 1, :yellow
+        return []
+      elsif response.status == 200
         begin
           data = JSON.parse(response.body)
           
           logs = data["Members"].map do |log|
             puts "#{log['Id']} : #{log['Created']} : #{log['Message']} : #{log['Severity']}".yellow
-            log
+            {
+              "id" => log["Id"],
+              "name" => log["Name"],
+              "created" => log["Created"],
+              "severity" => log["Severity"],
+              "message" => log["Message"],
+              "message_id" => log["MessageId"],
+              "sensor_type" => log["SensorType"],
+              "sensor_number" => log["SensorNumber"]
+            }
           end
           
           # Sort by creation date, newest first
-          return logs.sort_by { |log| log['Created'] }.reverse
+          return logs.sort_by { |log| log['created'] || "" }.reverse
         rescue JSON::ParserError
           raise Error, "Failed to parse system event logs response: #{response.body}"
         end
@@ -684,6 +699,9 @@ module IDRAC
         raise Error, "Failed to get system event logs. Status code: #{response.status}"
       end
     end
+    
+    # Alias for consistency with Supermicro naming
+    alias_method :sel_log, :system_event_logs
 
     # Clear system event logs
     def clear_system_event_logs
@@ -710,6 +728,37 @@ module IDRAC
         raise Error, error_message
       end
     end
+    
+    # Alias for consistency with Supermicro naming
+    alias_method :clear_sel_log, :clear_system_event_logs
+    
+    # SEL log summary - display recent entries
+    def sel_summary(limit: 10)
+      entries = sel_log
+      
+      if entries.empty?
+        puts "No log entries found.".yellow
+        return entries
+      end
+      
+      puts "Total entries: #{entries.length}".cyan
+      puts "\nMost recent #{limit} entries:".cyan
+      
+      entries.first(limit).each do |entry|
+        severity_color = case entry["severity"]
+                        when "Critical" then :red
+                        when "Warning" then :yellow
+                        when "OK" then :green
+                        else :white
+                        end
+        
+        puts "\n[#{entry['created']}] #{entry['severity']}".send(severity_color)
+        puts "  #{entry['message']}"
+        puts "  ID: #{entry['id']} | MessageID: #{entry['message_id']}" if entry['message_id']
+      end
+      
+      entries
+    end
 
     # Get total memory in human-readable format
     def total_memory_human(memory_data)

data/lib/idrac/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IDRAC
-  VERSION = "0.8.2"
+  VERSION = "0.8.4"
 end

data/lib/idrac/virtual_media.rb

@@ -215,33 +215,6 @@ module IDRAC
       end
     end
 
-    # Get current boot source override settings
-    def get_boot_source_override
-      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1")
-      
-      if response.status == 200
-        begin
-          data = JSON.parse(response.body)
-          boot = data["Boot"]
-          
-          puts "Boot Source Override Configuration:".green
-          puts "  Enabled: #{boot['BootSourceOverrideEnabled']}"
-          puts "  Target: #{boot['BootSourceOverrideTarget']}"
-          puts "  Mode: #{boot['BootSourceOverrideMode']}" if boot['BootSourceOverrideMode']
-          
-          if boot["BootSourceOverrideEnabled"] != "Once" || boot["BootSourceOverrideTarget"] == "None"
-            return "None"
-          else
-            return "#{boot['BootSourceOverrideMode']} #{boot['BootSourceOverrideTarget']}"
-          end
-        rescue JSON::ParserError
-          raise Error, "Failed to parse boot source response: #{response.body}"
-        end
-      else
-        raise Error, "Failed to get boot source override. Status code: #{response.status}"
-      end
-    end
-
     private
 
 

data/lib/idrac.rb

@@ -59,5 +59,6 @@ require 'idrac/boot'
 require 'idrac/license'
 require 'idrac/system_config'
 require 'idrac/utility'
+require 'idrac/network'
 # Client include must come last:
 require 'idrac/client'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.8.4
 platform: ruby
 authors:
 - Jonathan Siegel
@@ -254,6 +254,7 @@ files:
 - README.md
 - bin/console
 - bin/idrac
+- bin/idrac-tsr
 - bin/setup
 - idrac.gemspec
 - lib/idrac.rb
@@ -265,6 +266,7 @@ files:
 - lib/idrac/jobs.rb
 - lib/idrac/license.rb
 - lib/idrac/lifecycle.rb
+- lib/idrac/network.rb
 - lib/idrac/power.rb
 - lib/idrac/session.rb
 - lib/idrac/storage.rb