idrac 0.8.3 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ddf0acabc047b9ba1160d2c650b3590e7d6cc06d2d5c12aac37a4762fa85b7c
-  data.tar.gz: 40264a916185644f08009c693234d7463b929be7db77e8a1e4a1c28d13da70a0
+  metadata.gz: 1a568a5ab165447049ba41bcdb7f587089391ecc2c11e38cc294eb24205a3901
+  data.tar.gz: 783de976d1f0e6e67bd71f75b5368dd943c407d486b6ccc188a650d875c97234
 SHA512:
-  metadata.gz: be5ef5de0dac918e3f5cc55304b478cdba291a5637fecea1d456d993861246286d9601103aa20ac600a54c14acd15a92866fe455e96aa7cd7abebaf1ffbe5956
-  data.tar.gz: 5c148a96e54a35a8ffac7fca95163fb68ec86fd15500692210ebd9d3951ea836d25cb11d9a287379b7fbd265edd5fe0e67b57473aa6e9909b4f3578b33ba6d75
+  metadata.gz: fbe58debb5a55f90c0ffbe900e28eb20df76d49a3ac3729e9955a6bcc5ef0881f57aaff0aa5731bb9ec708fe044bbc0f4150a39c116324abbc9d16404a07365b
+  data.tar.gz: 899a0f5518a2bfc770408cd6592209e655bd5461cc8175fd84a9edc8c02f39ba768c776490dbfb073c0394ccbf956eb7f5c00a415b7b8bad020783ea9a4704bf

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/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

@@ -18,14 +18,18 @@ module IDRAC
           if response.status == 200
             data = JSON.parse(response.body)
             {
-              "ipv4_address" => data.dig("IPv4Addresses", 0, "Address"),
-              "subnet_mask" => data.dig("IPv4Addresses", 0, "SubnetMask"),
+              "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_address" => data["MACAddress"],
+              "mac" => data["MACAddress"],
               "hostname" => data["HostName"],
               "fqdn" => data["FQDN"],
-              "dns_servers" => data["NameServers"] || []
+              "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}"
@@ -38,7 +42,7 @@ module IDRAC
       end
     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)
       # Get the interface path first
@@ -65,14 +69,14 @@ module IDRAC
             body = {}
             
             # Configure static IP if provided
-            if ip_address && subnet_mask
+            if ipv4 && mask
               body["IPv4Addresses"] = [{
-                "Address" => ip_address,
-                "SubnetMask" => subnet_mask,
+                "Address" => ipv4,
+                "SubnetMask" => mask,
                 "Gateway" => gateway,
                 "AddressOrigin" => "Static"
               }]
-              puts "  IP: #{ip_address}/#{subnet_mask}".cyan
+              puts "  IP: #{ipv4}/#{mask}".cyan
               puts "  Gateway: #{gateway}".cyan if gateway
             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
           
@@ -48,15 +50,17 @@ module IDRAC
           
           psus = data["PowerSupplies"].map do |psu|
             puts "PSU: #{psu["Name"]} > #{psu["PowerInputWatts"]}W > #{psu.dig("Status", "Health")}"
+            
             {
               "name" => psu["Name"], 
               "voltage" => psu["LineInputVoltage"], 
-              "voltage_human" => psu["LineInputVoltageType"], # AC240V
+              "voltage_human" => psu["LineInputVoltageType"],  # Return exactly what server provides
               "watts" => psu["PowerInputWatts"],
               "part" => psu["PartNumber"],
               "model" => psu["Model"],
               "serial" => psu["SerialNumber"],
-              "status" => psu.dig("Status", "Health")
+              "status" => psu.dig("Status", "Health"),
+              "power_supply_type" => psu["PowerSupplyType"]  # Add this field
             }
           end
           
@@ -87,7 +91,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 +651,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 +671,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 +701,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 +730,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.3"
+  VERSION = "0.8.5"
 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
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.5
 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