idrac 0.1.26 → 0.1.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d751ffb6e590b80a6a5dc72457d8a4be11213224a13ebeae50698ae9f6cafff
-  data.tar.gz: 5a3f826850bf9aee8e40287ff7f8ab7c5bd71944ddce2b183dbe88dabed9c3fa
+  metadata.gz: 6c080d98bd3ca44b9cc006ba66cc443ec410dcfb6bc1b712141720cc82998884
+  data.tar.gz: fe0e09d1e3089c5d354abf6f786624d5afd7dfbcd7b2984d84a72be9936dcf9c
 SHA512:
-  metadata.gz: 553bef804c000680be8ecadb15c19f2b4a335db5a7a44b5071ccb230f168880268e906f5a296a70c8659a5bbbb14a0ffb3a6f56cfc4c9ca216e0a1f8a6024a0f
-  data.tar.gz: ff4d0ce0967de6fbddd425844e0c86165276c44d508a2b8de41a20ec54e3998f7d2f1d5aa7cadf34201dd26113bd0abafb1e01d13439edbcb1d22f273e31a1f5
+  metadata.gz: 479b4ceb21686d4803a3f780f8fe19fcd1741f17cf3b1e24cd0039bd7758688810260dd939fe60cfe07b3b829feefcfbeee4953826f315b65707d2467121fa6c
+  data.tar.gz: 1855a7715e1267c505cc20f9dfd9a9e0665b78ac4db5b06a6984503bb88fb849e7f41b9ebeb68b6e67a70d0b663ea3a6f9b7bbecd1e4c5e194aff198ca9b5238

data/README.md

@@ -37,8 +37,10 @@ idrac screenshot --host=192.168.1.100 --username=root --password=calvin
 # Specify a custom output filename
 idrac screenshot --host=192.168.1.100 --username=root --password=calvin --output=my_screenshot.png
 
-# Download the Dell firmware catalog
-idrac firmware:catalog --host=192.168.1.100 --username=root --password=calvin
+# Download the Dell firmware catalog (no host required)
+idrac catalog download
+# or
+idrac firmware:catalog
 
 # Check firmware status and available updates
 idrac firmware:status --host=192.168.1.100 --username=root --password=calvin
@@ -93,8 +95,9 @@ puts "Screenshot saved to: #{filename}"
 # Firmware operations
 firmware = IDRAC::Firmware.new(client)
 
-# Download catalog
-catalog_path = firmware.download_catalog
+# Download catalog (no client required)
+catalog = IDRAC::FirmwareCatalog.new
+catalog_path = catalog.download
 
 # Get system inventory
 inventory = firmware.get_system_inventory
@@ -127,6 +130,21 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Changelog
 
+### Version 0.1.28
+- **Improved Firmware Update Checking**: Completely redesigned the firmware update checking process
+- Added a dedicated `FirmwareCatalog` class for better separation of concerns
+- Improved component matching with more accurate detection of available updates
+- Enhanced output format with a tabular display showing component details, versions, and update status
+- Added system model detection for more accurate firmware matching
+- Improved version comparison logic for different version formats (numeric, Dell A00 format, etc.)
+- Better handling of network adapters and other component types
+
+### Version 0.1.27
+- **Removed Host Requirement for Catalog Download**: The `catalog download` and `firmware:catalog` commands no longer require the `--host` parameter
+- Added a dedicated `catalog` command that can be used directly: `idrac catalog download`
+- The catalog download functionality can now be used without an iDRAC connection
+- Updated the Ruby API to support catalog downloads without a client
+
 ### Version 0.1.26
 - **Improved Redfish Session Creation**: Fixed issues with the Redfish session creation process
 - Added multiple fallback methods for creating sessions with different iDRAC versions

data/bin/idrac

@@ -13,7 +13,8 @@ require "idrac"
 
 module IDRAC
   class CLI < Thor
-    class_option :host, type: :string, required: true, desc: "iDRAC host address"
+    # Make host not required for all commands
+    class_option :host, type: :string, required: false, desc: "iDRAC host address"
     class_option :username, type: :string, required: false, default: "root", desc: "iDRAC username (default: root)"
     class_option :password, type: :string, required: false, default: "calvin", desc: "iDRAC password (default: calvin)"
     class_option :port, type: :numeric, default: 443, desc: "iDRAC port"
@@ -25,6 +26,9 @@ module IDRAC
     method_option :wait, type: :boolean, default: true, desc: "Wait for the update to complete"
     method_option :timeout, type: :numeric, default: 3600, desc: "Timeout in seconds when waiting"
     def firmware_update(path)
+      # Ensure host is provided for commands that need it
+      ensure_host_provided
+      
       check_ssl_verification
       client = create_client
       firmware = IDRAC::Firmware.new(client)
@@ -42,24 +46,25 @@ module IDRAC
     
     desc "firmware:catalog [DIRECTORY]", "Download Dell firmware catalog"
     def firmware_catalog(directory = nil)
-      check_ssl_verification
-      client = create_client
-      firmware = IDRAC::Firmware.new(client)
+      # This command doesn't require a host
+      # Create a FirmwareCatalog instance directly
+      catalog = IDRAC::FirmwareCatalog.new
       
       begin
-        catalog_path = firmware.download_catalog(directory)
+        catalog_path = catalog.download(directory)
         puts "Catalog downloaded to: #{catalog_path}"
       rescue IDRAC::Error => e
         puts "Error: #{e.message}"
         exit 1
-      ensure
-        client.logout
       end
     end
     
     desc "firmware:status", "Show current firmware status and available updates"
     method_option :catalog, type: :string, desc: "Path to existing catalog file"
     def firmware_status
+      # Ensure host is provided for commands that need it
+      ensure_host_provided
+      
       check_ssl_verification
       client = create_client
       firmware = IDRAC::Firmware.new(client)
@@ -85,17 +90,12 @@ module IDRAC
         # Check for updates if catalog is available
         if options[:catalog] || File.exist?(default_catalog)
           catalog_path = options[:catalog] || default_catalog
-          puts "\nChecking for updates using catalog: #{catalog_path}"
           
+          # Check for updates using the firmware class
           updates = firmware.check_updates(catalog_path)
           
           if updates.empty?
             puts "No updates available."
-          else
-            puts "\nAvailable Updates:"
-            updates.each do |update|
-              puts "  #{update[:name]}: #{update[:current_version]} -> #{update[:available_version]}"
-            end
           end
         else
           puts "\nTo check for updates, download the catalog first with 'idrac firmware:catalog'"
@@ -111,6 +111,9 @@ module IDRAC
     desc "firmware:interactive", "Interactive firmware update"
     method_option :catalog, type: :string, desc: "Path to existing catalog file"
     def firmware_interactive
+      # Ensure host is provided for commands that need it
+      ensure_host_provided
+      
       check_ssl_verification
       client = create_client
       firmware = IDRAC::Firmware.new(client)
@@ -129,11 +132,40 @@ module IDRAC
         # If still no catalog, download it
         if catalog_path.nil?
           puts "No catalog found. Downloading..."
-          catalog_path = firmware.download_catalog
+          catalog = IDRAC::FirmwareCatalog.new
+          catalog_path = catalog.download
         end
         
-        firmware.interactive_update(catalog_path)
-      rescue IDRAC::Error => e
+        puts "Starting interactive firmware update. Please note:"
+        puts "- The iDRAC can only process one firmware update at a time"
+        puts "- Updates may take several minutes to complete"
+        puts "- For BIOS updates, a server reboot will be required to apply the update"
+        puts "- If you encounter errors, check the iDRAC web interface for active jobs"
+        puts ""
+        
+        begin
+          firmware.interactive_update(catalog_path)
+        rescue ArgumentError => e
+          puts "Error: #{e.message}"
+          puts "This could be due to an issue with the interactive update process."
+          puts "If you're seeing a 'job ID not found' error, it might be because:"
+          puts "1. The firmware update job wasn't created properly"
+          puts "2. There's already an update in progress"
+          puts "3. The iDRAC needs time to process the previous request"
+          puts "\nTry again in a few minutes or check the iDRAC web interface for active jobs."
+        rescue IDRAC::Error => e
+          if e.message.include?("already in progress")
+            puts "Error: #{e.message}"
+            puts "\nTroubleshooting steps:"
+            puts "1. Check the iDRAC web interface under Maintenance > System Update for active jobs"
+            puts "2. Wait for any existing updates to complete (can take 15-30 minutes)"
+            puts "3. If no updates appear to be in progress, you may need to restart the iDRAC"
+            puts "   (iDRAC web interface > Settings > iDRAC Settings > Reset iDRAC)"
+          else
+            puts "Error: #{e.message}"
+          end
+        end
+      rescue => e
         puts "Error: #{e.message}"
         exit 1
       ensure
@@ -144,6 +176,9 @@ module IDRAC
     desc "screenshot", "Take a screenshot of the current iDRAC console"
     method_option :output, type: :string, desc: "Output filename (default: idrac_screenshot_timestamp.png)"
     def screenshot
+      # Ensure host is provided for commands that need it
+      ensure_host_provided
+      
       check_ssl_verification
       client = create_client
       
@@ -175,6 +210,13 @@ module IDRAC
 
     private
 
+    def ensure_host_provided
+      unless options[:host]
+        puts "Error: No value provided for required option '--host'"
+        exit 1
+      end
+    end
+
     def check_ssl_verification
       # If verify_ssl is not explicitly set in the command line, show a warning
       unless ARGV.include?('--verify-ssl') || ARGV.include?('--no-verify-ssl')
@@ -198,4 +240,5 @@ module IDRAC
   end
 end
 
+# Start the CLI
 IDRAC::CLI.start(ARGV) 

data/lib/idrac/error.rb

@@ -0,0 +1,3 @@
+module IDRAC
+  class Error < StandardError; end
+end 

data/lib/idrac/firmware.rb

@@ -5,6 +5,8 @@ require 'json'
 require 'nokogiri'
 require 'fileutils'
 require 'securerandom'
+require 'set'
+require_relative 'firmware_catalog'
 
 module IDRAC
   class Firmware
@@ -22,6 +24,9 @@ module IDRAC
         raise Error, "Firmware file not found: #{firmware_path}"
       end
 
+      # Ensure we have a client
+      raise Error, "Client is required for firmware update" unless client
+
       # Login to iDRAC
       client.login unless client.instance_variable_get(:@session_id)
 
@@ -37,43 +42,15 @@ module IDRAC
     end
     
     def download_catalog(output_dir = nil)
-      # Use ~/.idrac as the default directory
-      output_dir ||= File.expand_path("~/.idrac")
-      FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
-      
-      catalog_gz_path = File.join(output_dir, "Catalog.xml.gz")
-      catalog_path = File.join(output_dir, "Catalog.xml")
-      
-      puts "Downloading Dell catalog from #{CATALOG_URL}..."
-      
-      uri = URI.parse(CATALOG_URL)
-      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-        request = Net::HTTP::Get.new(uri)
-        http.request(request) do |response|
-          if response.code == "200"
-            File.open(catalog_gz_path, 'wb') do |file|
-              response.read_body do |chunk|
-                file.write(chunk)
-              end
-            end
-          else
-            raise Error, "Failed to download catalog: #{response.code} #{response.message}"
-          end
-        end
-      end
-      
-      puts "Extracting catalog..."
-      system("gunzip -f #{catalog_gz_path}")
-      
-      if File.exist?(catalog_path)
-        puts "Catalog downloaded and extracted to #{catalog_path}"
-        return catalog_path
-      else
-        raise Error, "Failed to extract catalog"
-      end
+      # Use the new FirmwareCatalog class
+      catalog = FirmwareCatalog.new
+      catalog.download(output_dir)
     end
     
     def get_system_inventory
+      # Ensure we have a client
+      raise Error, "Client is required for system inventory" unless client
+      
       puts "Retrieving system inventory..."
       
       # Get basic system information
@@ -133,150 +110,172 @@ module IDRAC
     end
     
     def check_updates(catalog_path = nil)
+      # Ensure we have a client for system inventory
+      raise Error, "Client is required for checking updates" unless client
+      
       # Download catalog if not provided
       catalog_path ||= download_catalog
       
       # Get system inventory
       inventory = get_system_inventory
       
-      # Parse catalog
-      catalog_doc = File.open(catalog_path) { |f| Nokogiri::XML(f) }
+      # Create a FirmwareCatalog instance
+      catalog = FirmwareCatalog.new(catalog_path)
       
-      # Extract service tag
+      # Extract system information
+      system_model = inventory[:system][:model]
       service_tag = inventory[:system][:service_tag]
       
       puts "Checking updates for system with service tag: #{service_tag}"
+      puts "Searching for updates for model: #{system_model}"
       
-      # Find applicable updates
-      updates = []
+      # Find system models in the catalog
+      models = catalog.find_system_models(system_model)
       
-      # Get current firmware versions
-      current_versions = {}
-      inventory[:firmware].each do |fw|
-        # Use the ID as the key to avoid duplicates
-        current_versions[fw[:id]] = {
-          name: fw[:name],
-          version: fw[:version],
-          updateable: fw[:updateable],
-          identifiers: extract_identifiers(fw[:name]) # Extract identifiers for better matching
-        }
+      if models.empty?
+        puts "No matching system model found in catalog"
+        return []
       end
       
-      # Find matching components in catalog
-      catalog_doc.xpath('//SoftwareComponent').each do |component|
-        name = component.at_xpath('Name')&.text
-        version = component.at_xpath('Version')&.text
-        path = component.at_xpath('Path')&.text
-        component_type = component.at_xpath('ComponentType')&.text
-        
-        next unless name && version && path # Skip if missing essential data
+      # Use the first matching model
+      model = models.first
+      puts "Found system IDs for #{model[:name]}: #{model[:id]}"
+      
+      # Find updates for this system
+      catalog_updates = catalog.find_updates_for_system(model[:id])
+      puts "Found #{catalog_updates.size} firmware updates for #{model[:name]}"
+      
+      # Compare current firmware with available updates
+      updates = []
+      
+      # Print header for firmware comparison table
+      puts "\nFirmware Version Comparison:"
+      puts "=" * 100
+      puts "%-30s %-20s %-20s %-10s %-15s %s" % ["Component", "Current Version", "Available Version", "Updateable", "Category", "Status"]
+      puts "-" * 100
+      
+      # Track components we've already displayed to avoid duplicates
+      displayed_components = Set.new
+      
+      # First show current firmware with available updates
+      inventory[:firmware].each do |fw|
+        # Make sure firmware name is not nil
+        firmware_name = fw[:name] || ""
         
-        # Extract identifiers from catalog component name for better matching
-        catalog_identifiers = extract_identifiers(name)
+        # Skip if we've already displayed this component
+        next if displayed_components.include?(firmware_name.downcase)
+        displayed_components.add(firmware_name.downcase)
         
-        # Check if this component matches any of our firmware
-        # We'll track if we found a match to avoid duplicates
-        matched = false
+        # Extract key identifiers from the firmware name
+        identifiers = extract_identifiers(firmware_name)
         
-        current_versions.each do |id, fw_info|
-          # Skip if not updateable
-          next unless fw_info[:updateable]
-          
-          # Normalize names for comparison
-          catalog_name = name.downcase.strip
-          firmware_name = fw_info[:name].downcase.strip
-          
-          # Check for matches using multiple strategies
-          match_found = false
-          
-          # 1. Check if names contain each other
-          if catalog_name.include?(firmware_name) || firmware_name.include?(catalog_name)
-            match_found = true
-          end
+        # Try to find a matching update
+        matching_updates = catalog_updates.select do |update|
+          update_name = update[:name] || ""
           
-          # 2. Check if BIOS components match
-          if (catalog_name.include?("bios") && firmware_name.include?("bios"))
-            match_found = true
-          end
+          # Check if any of our identifiers match the update name
+          identifiers.any? { |id| update_name.downcase.include?(id.downcase) } ||
+          # Or if the update name contains the firmware name
+          update_name.downcase.include?(firmware_name.downcase) ||
+          # Or if the firmware name contains the update name
+          firmware_name.downcase.include?(update_name.downcase)
+        end
+        
+        if matching_updates.any?
+          # Use the first matching update
+          update = matching_updates.first
           
-          # 3. Check if identifiers match
-          if !match_found && !fw_info[:identifiers].empty? && !catalog_identifiers.empty?
-            # Check if any identifier from firmware matches any identifier from catalog
-            if (fw_info[:identifiers] & catalog_identifiers).any?
-              match_found = true
-            end
-          end
+          # Check if version is newer
+          needs_update = catalog.compare_versions(fw[:version], update[:version])
           
-          # If we found a match and versions differ, add to updates
-          if match_found && !matched && version != fw_info[:version]
+          # Add to updates list if needed
+          if needs_update && fw[:updateable]
             updates << {
-              name: name,
-              current_version: fw_info[:version],
-              available_version: version,
-              path: path,
-              component_type: component_type,
-              download_url: "https://downloads.dell.com/#{path}"
+              name: fw[:name],
+              current_version: fw[:version],
+              available_version: update[:version],
+              path: update[:path],
+              component_type: update[:component_type],
+              category: update[:category],
+              download_url: update[:download_url]
             }
             
-            # Mark as matched to avoid duplicates
-            matched = true
+            # Print row with update available
+            puts "%-30s %-20s %-20s %-10s %-15s %s" % [
+              fw[:name].to_s[0..29],
+              fw[:version],
+              update[:version],
+              fw[:updateable] ? "Yes" : "No",
+              update[:category] || "N/A",
+              "UPDATE AVAILABLE"
+            ]
+          else
+            # Print row with no update needed
+            status = if !needs_update
+                       "Current"
+                     elsif !fw[:updateable]
+                       "Not updateable"
+                     else
+                       "No update needed"
+                     end
+            
+            puts "%-30s %-20s %-20s %-10s %-15s %s" % [
+              fw[:name].to_s[0..29],
+              fw[:version],
+              update[:version] || "N/A",
+              fw[:updateable] ? "Yes" : "No",
+              update[:category] || "N/A",
+              status
+            ]
           end
+        else
+          # No matching update found
+          puts "%-30s %-20s %-20s %-10s %-15s %s" % [
+            fw[:name].to_s[0..29],
+            fw[:version],
+            "N/A",
+            fw[:updateable] ? "Yes" : "No",
+            "N/A",
+            "No update available"
+          ]
         end
       end
       
-      updates
-    end
-    
-    def extract_identifiers(name)
-      return [] unless name
-      
-      identifiers = []
-      
-      # Extract model numbers like X520, I350, etc.
-      model_matches = name.scan(/[IX]\d{3,4}/)
-      identifiers.concat(model_matches)
-      
-      # Extract PERC model like H730
-      perc_matches = name.scan(/[HP]\d{3,4}/)
-      identifiers.concat(perc_matches)
-      
-      # Extract other common identifiers
-      if name.include?("NIC") || name.include?("Ethernet") || name.include?("Network")
-        identifiers << "NIC"
-      end
-      
-      if name.include?("PERC") || name.include?("RAID")
-        identifiers << "PERC"
-        # Extract PERC model like H730
-        perc_match = name.match(/PERC\s+([A-Z]\d{3})/)
-        identifiers << perc_match[1] if perc_match
-      end
-      
-      if name.include?("BIOS")
-        identifiers << "BIOS"
-      end
-      
-      if name.include?("iDRAC") || name.include?("IDRAC") || name.include?("Remote Access Controller")
-        identifiers << "iDRAC"
-      end
-      
-      if name.include?("Power Supply") || name.include?("PSU")
-        identifiers << "PSU"
-      end
-      
-      if name.include?("Lifecycle Controller")
-        identifiers << "LC"
+      # Then show available updates that don't match any current firmware
+      catalog_updates.each do |update|
+        update_name = update[:name] || ""
+        
+        # Skip if we've already displayed this component
+        next if displayed_components.include?(update_name.downcase)
+        displayed_components.add(update_name.downcase)
+        
+        # Skip if this update was already matched to a current firmware
+        next if inventory[:firmware].any? do |fw|
+          firmware_name = fw[:name] || ""
+          identifiers = extract_identifiers(firmware_name)
+          
+          identifiers.any? { |id| update_name.downcase.include?(id.downcase) } ||
+          update_name.downcase.include?(firmware_name.downcase) ||
+          firmware_name.downcase.include?(update_name.downcase)
+        end
+        
+        puts "%-30s %-20s %-20s %-10s %-15s %s" % [
+          update_name.to_s[0..29],
+          "Not Installed",
+          update[:version] || "Unknown",
+          "N/A",
+          update[:category] || "N/A",
+          "NEW COMPONENT"
+        ]
       end
       
-      if name.include?("CPLD")
-        identifiers << "CPLD"
-      end
+      puts "=" * 100
       
-      identifiers
+      updates
     end
     
-    def interactive_update(catalog_path = nil)
-      updates = check_updates(catalog_path)
+    def interactive_update(catalog_path = nil, selected_updates = nil)
+      updates = selected_updates || check_updates(catalog_path)
       
       if updates.empty?
         puts "No updates available for your system."
@@ -288,24 +287,30 @@ module IDRAC
         puts "#{index + 1}. #{update[:name]}: #{update[:current_version]} -> #{update[:available_version]}"
       end
       
-      puts "\nEnter the number of the update to install (or 'all' for all updates, 'q' to quit):"
-      choice = STDIN.gets.chomp
-      
-      return if choice.downcase == 'q'
-      
-      selected_updates = if choice.downcase == 'all'
-                          updates
-                        else
-                          index = choice.to_i - 1
-                          if index >= 0 && index < updates.size
-                            [updates[index]]
-                          else
-                            puts "Invalid selection."
-                            return
-                          end
-                        end
+      # If selected_updates is provided, use those directly
+      if selected_updates
+        selected = selected_updates
+      else
+        # Otherwise prompt the user for selection
+        puts "\nEnter the number of the update to install (or 'all' for all updates, 'q' to quit):"
+        choice = STDIN.gets.chomp
+        
+        return if choice.downcase == 'q'
+        
+        selected = if choice.downcase == 'all'
+                      updates
+                    else
+                      index = choice.to_i - 1
+                      if index >= 0 && index < updates.size
+                        [updates[index]]
+                      else
+                        puts "Invalid selection."
+                        return
+                      end
+                    end
+      end
       
-      selected_updates.each do |update|
+      selected.each do |update|
         puts "Downloading #{update[:name]} version #{update[:available_version]}..."
         
         # Create temp directory
@@ -334,8 +339,28 @@ module IDRAC
           end
           
           puts "Installing #{update[:name]} version #{update[:available_version]}..."
-          job_id = update(update_path, wait: true)
-          puts "Update completed with job ID: #{job_id}"
+          
+          begin
+            job_id = update(update_path, wait: true)
+            puts "Update completed with job ID: #{job_id}"
+          rescue IDRAC::Error => e
+            if e.message.include?("already in progress")
+              puts "Error: #{e.message}"
+              puts "\nTips for resolving this issue:"
+              puts "1. Wait for any existing firmware updates to complete (check iDRAC web interface)"
+              puts "2. Restart the iDRAC if no updates appear to be in progress (Settings > iDRAC Settings > Reset iDRAC)"
+              puts "3. Try again after a few minutes"
+            elsif e.message.include?("job ID") || e.message.include?("job not found")
+              puts "Error: #{e.message}"
+              puts "\nThe job ID could not be found or monitored. This could be because:"
+              puts "1. The iDRAC is busy processing other requests"
+              puts "2. The job was created but not properly tracked"
+              puts "3. The iDRAC firmware may need to be updated first"
+              puts "\nCheck the iDRAC web interface to see if the update was actually initiated."
+            else
+              puts "Error during firmware update: #{e.message}"
+            end
+          end
           
         ensure
           # Clean up temp directory
@@ -383,28 +408,103 @@ module IDRAC
       post_body << "\r\n--#{boundary}--\r\n"
       
       # Upload the firmware
-      response = client.authenticated_request(
+      begin
+        response = client.authenticated_request(
+          :post,
+          http_push_uri,
+          {
+            headers: {
+              'Content-Type' => "multipart/form-data; boundary=#{boundary}",
+              'If-Match' => etag
+            },
+            body: post_body.join
+          }
+        )
+      rescue => e
+        # Check if the error is about a deployment already in progress
+        if e.message.include?("A deployment or update operation is already in progress")
+          raise Error, "A firmware update is already in progress on the iDRAC. Please wait for it to complete before starting another update. You can check the status in the iDRAC web interface under Maintenance > System Update."
+        else
+          # Re-raise the original error
+          raise
+        end
+      end
+      
+      if response.status < 200 || response.status >= 300
+        error_message = response.body.to_s
+        
+        # Check for specific error messages in the response
+        if error_message.include?("A deployment or update operation is already in progress")
+          raise Error, "A firmware update is already in progress on the iDRAC. Please wait for it to complete before starting another update. You can check the status in the iDRAC web interface under Maintenance > System Update."
+        elsif error_message.include?("SUP0108")
+          raise Error, "iDRAC Error SUP0108: A deployment or update operation is already in progress. Wait for the operation to conclude and then try again."
+        else
+          raise Error, "Firmware upload failed with status #{response.status}: #{response.body}"
+        end
+      end
+      
+      # Extract upload ID from response
+      response_data = JSON.parse(response.body)
+      upload_id = response_data['Id'] || response_data['TaskId']
+      
+      if upload_id.nil?
+        raise Error, "Failed to extract upload ID from firmware upload response"
+      end
+      
+      puts "Firmware file uploaded successfully with ID: #{upload_id}"
+      
+      # Step 2: Initiate the firmware update using SimpleUpdate
+      puts "Initiating firmware update using SimpleUpdate..."
+      
+      # Construct the image URI using the uploaded file
+      image_uri = "#{http_push_uri}/#{upload_id}"
+      puts "Using ImageURI: #{image_uri}"
+      
+      # Call the SimpleUpdate action
+      simple_update_response = client.authenticated_request(
         :post,
-        http_push_uri,
+        "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate",
         {
           headers: {
-            'Content-Type' => "multipart/form-data; boundary=#{boundary}",
-            'If-Match' => etag
+            'Content-Type' => 'application/json'
           },
-          body: post_body.join
+          body: JSON.generate({
+            'ImageURI' => image_uri,
+            '@Redfish.OperationApplyTime' => 'Immediate'
+          })
         }
       )
       
-      if response.status < 200 || response.status >= 300
-        raise Error, "Firmware upload failed with status #{response.status}: #{response.body}"
+      if simple_update_response.status < 200 || simple_update_response.status >= 300
+        raise Error, "Firmware update initiation failed with status #{simple_update_response.status}: #{simple_update_response.body}"
       end
       
       # Extract job ID from response
-      response_data = JSON.parse(response.body)
-      job_id = response_data['Id'] || response_data['TaskId']
+      job_id = nil
+      
+      # Try to get job ID from Location header
+      if simple_update_response.headers['location']
+        job_id = simple_update_response.headers['location'].split('/').last
+      end
       
+      # If not found in header, try to get from response body
+      if job_id.nil? && !simple_update_response.body.empty?
+        begin
+          update_data = JSON.parse(simple_update_response.body)
+          if update_data['@odata.id']
+            job_id = update_data['@odata.id'].split('/').last
+          elsif update_data['Id']
+            job_id = update_data['Id']
+          end
+        rescue JSON::ParserError
+          # Not JSON, ignore
+        end
+      end
+      
+      # If still no job ID, use the upload ID as a fallback
       if job_id.nil?
-        raise Error, "Failed to extract job ID from firmware upload response"
+        job_id = upload_id
+        puts "No job ID found in SimpleUpdate response, using upload ID as job ID"
       end
       
       puts "Firmware update job created with ID: #{job_id}"
@@ -452,5 +552,54 @@ module IDRAC
       response_data = JSON.parse(response.body)
       response_data['TaskState'] || 'Unknown'
     end
+
+    # Helper method to extract identifiers from component names
+    def extract_identifiers(name)
+      return [] unless name
+      
+      identifiers = []
+      
+      # Extract model numbers like X520, I350, etc.
+      model_matches = name.scan(/[IX]\d{3,4}/)
+      identifiers.concat(model_matches)
+      
+      # Extract PERC model like H730
+      perc_matches = name.scan(/[HP]\d{3,4}/)
+      identifiers.concat(perc_matches)
+      
+      # Extract other common identifiers
+      if name.include?("NIC") || name.include?("Ethernet") || name.include?("Network")
+        identifiers << "NIC"
+      end
+      
+      if name.include?("PERC") || name.include?("RAID")
+        identifiers << "PERC"
+        # Extract PERC model like H730
+        perc_match = name.match(/PERC\s+([A-Z]\d{3})/)
+        identifiers << perc_match[1] if perc_match
+      end
+      
+      if name.include?("BIOS")
+        identifiers << "BIOS"
+      end
+      
+      if name.include?("iDRAC") || name.include?("IDRAC") || name.include?("Remote Access Controller")
+        identifiers << "iDRAC"
+      end
+      
+      if name.include?("Power Supply") || name.include?("PSU")
+        identifiers << "PSU"
+      end
+      
+      if name.include?("Lifecycle Controller")
+        identifiers << "LC"
+      end
+      
+      if name.include?("CPLD")
+        identifiers << "CPLD"
+      end
+      
+      identifiers
+    end
   end
 end 

data/lib/idrac/firmware_catalog.rb

@@ -0,0 +1,314 @@
+require 'net/http'
+require 'uri'
+require 'fileutils'
+require 'nokogiri'
+
+module IDRAC
+  class FirmwareCatalog
+    CATALOG_URL = "https://downloads.dell.com/catalog/Catalog.xml.gz"
+    
+    attr_reader :catalog_path
+    
+    def initialize(catalog_path = nil)
+      @catalog_path = catalog_path
+    end
+    
+    def download(output_dir = nil)
+      # Use ~/.idrac as the default directory
+      output_dir ||= File.expand_path("~/.idrac")
+      FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+      
+      catalog_gz_path = File.join(output_dir, "Catalog.xml.gz")
+      catalog_path = File.join(output_dir, "Catalog.xml")
+      
+      puts "Downloading Dell catalog from #{CATALOG_URL}..."
+      
+      uri = URI.parse(CATALOG_URL)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        request = Net::HTTP::Get.new(uri)
+        http.request(request) do |response|
+          if response.code == "200"
+            File.open(catalog_gz_path, 'wb') do |file|
+              response.read_body do |chunk|
+                file.write(chunk)
+              end
+            end
+          else
+            raise Error, "Failed to download catalog: #{response.code} #{response.message}"
+          end
+        end
+      end
+      
+      puts "Extracting catalog..."
+      system("gunzip -f #{catalog_gz_path}")
+      
+      if File.exist?(catalog_path)
+        puts "Catalog downloaded and extracted to #{catalog_path}"
+        @catalog_path = catalog_path
+        return catalog_path
+      else
+        raise Error, "Failed to extract catalog"
+      end
+    end
+    
+    def parse
+      raise Error, "No catalog path specified" unless @catalog_path
+      raise Error, "Catalog file not found: #{@catalog_path}" unless File.exist?(@catalog_path)
+      
+      File.open(@catalog_path) { |f| Nokogiri::XML(f) }
+    end
+    
+    def find_system_models(model_name)
+      doc = parse
+      models = []
+      
+      # Extract model code from full model name (e.g., "PowerEdge R640" -> "R640")
+      model_code = nil
+      if model_name.include?("PowerEdge")
+        model_code = model_name.split.last
+      else
+        model_code = model_name
+      end
+      
+      puts "Searching for model: #{model_name} (code: #{model_code})"
+      
+      # Build a mapping of model names to system IDs
+      model_to_system_id = {}
+      
+      doc.xpath('//SupportedSystems/Brand/Model').each do |model|
+        system_id = model['systemID'] || model['id']
+        name = model.at_xpath('Display')&.text
+        code = model.at_xpath('Code')&.text
+        
+        if name && system_id
+          model_to_system_id[name] = {
+            name: name,
+            code: code,
+            id: system_id
+          }
+          
+          # Also map just the model number (R640, etc.)
+          if name =~ /[RT]\d+/
+            model_short = name.match(/([RT]\d+\w*)/)[1]
+            model_to_system_id[model_short] = {
+              name: name,
+              code: code,
+              id: system_id
+            }
+          end
+        end
+      end
+      
+      # Try exact match first
+      if model_to_system_id[model_name]
+        models << model_to_system_id[model_name]
+      end
+      
+      # Try model code match
+      if model_to_system_id[model_code]
+        models << model_to_system_id[model_code]
+      end
+      
+      # If we still don't have a match, try a more flexible approach
+      if models.empty?
+        model_to_system_id.each do |name, model_info|
+          if name.include?(model_code) || model_code.include?(name)
+            models << model_info
+          end
+        end
+      end
+      
+      # If still no match, try matching by systemID directly
+      if models.empty?
+        doc.xpath('//SupportedSystems/Brand/Model').each do |model|
+          system_id = model['systemID'] || model['id']
+          name = model.at_xpath('Display')&.text
+          code = model.at_xpath('Code')&.text
+          
+          if code && code.downcase == model_code.downcase
+            models << {
+              name: name,
+              code: code,
+              id: system_id
+            }
+          end
+        end
+      end
+      
+      models.uniq { |m| m[:id] }
+    end
+    
+    def find_updates_for_system(system_id)
+      doc = parse
+      updates = []
+      
+      # Find all SoftwareComponents
+      doc.xpath("//SoftwareComponent").each do |component|
+        # Check if this component supports our system ID
+        supported_system_ids = component.xpath(".//SupportedSystems/Brand/Model/@systemID | .//SupportedSystems/Brand/Model/@id").map(&:value)
+        
+        next unless supported_system_ids.include?(system_id)
+        
+        # Get component details
+        name_node = component.xpath("./Name/Display[@lang='en']").first
+        name = name_node ? name_node.text.strip : ""
+        
+        component_type_node = component.xpath("./ComponentType/Display[@lang='en']").first
+        component_type = component_type_node ? component_type_node.text.strip : ""
+        
+        path = component['path'] || ""
+        category_node = component.xpath("./Category/Display[@lang='en']").first
+        category = category_node ? category_node.text.strip : ""
+        
+        version = component['dellVersion'] || component['vendorVersion'] || ""
+        
+        # Skip if missing essential information
+        next if name.empty? || path.empty? || version.empty?
+        
+        # Only include firmware updates
+        if component_type.include?("Firmware") ||
+           category.include?("BIOS") ||
+           category.include?("Firmware") ||
+           category.include?("iDRAC") ||
+           name.include?("BIOS") ||
+           name.include?("Firmware") ||
+           name.include?("iDRAC")
+          
+          updates << {
+            name: name,
+            version: version,
+            path: path,
+            component_type: component_type,
+            category: category,
+            download_url: "https://downloads.dell.com/#{path}"
+          }
+        end
+      end
+      
+      puts "Found #{updates.size} firmware updates for system ID #{system_id}"
+      updates
+    end
+    
+    def extract_identifiers(name)
+      return [] unless name
+      
+      identifiers = []
+      
+      # Extract model numbers like X520, I350, etc.
+      model_matches = name.scan(/[IX]\d{3,4}/)
+      identifiers.concat(model_matches)
+      
+      # Extract PERC model like H730
+      perc_matches = name.scan(/[HP]\d{3,4}/)
+      identifiers.concat(perc_matches)
+      
+      # Extract other common identifiers
+      if name.include?("NIC") || name.include?("Ethernet") || name.include?("Network")
+        identifiers << "NIC"
+      end
+      
+      if name.include?("PERC") || name.include?("RAID")
+        identifiers << "PERC"
+        # Extract PERC model like H730
+        perc_match = name.match(/PERC\s+([A-Z]\d{3})/)
+        identifiers << perc_match[1] if perc_match
+      end
+      
+      if name.include?("BIOS")
+        identifiers << "BIOS"
+      end
+      
+      if name.include?("iDRAC") || name.include?("IDRAC") || name.include?("Remote Access Controller")
+        identifiers << "iDRAC"
+      end
+      
+      if name.include?("Power Supply") || name.include?("PSU")
+        identifiers << "PSU"
+      end
+      
+      if name.include?("Lifecycle Controller")
+        identifiers << "LC"
+      end
+      
+      if name.include?("CPLD")
+        identifiers << "CPLD"
+      end
+      
+      identifiers
+    end
+    
+    def match_component(firmware_name, catalog_name)
+      # Normalize names for comparison
+      catalog_name_lower = catalog_name.downcase.strip
+      firmware_name_lower = firmware_name.downcase.strip
+      
+      # 1. Direct substring match
+      return true if catalog_name_lower.include?(firmware_name_lower) || firmware_name_lower.include?(catalog_name_lower)
+      
+      # 2. Special case for BIOS
+      return true if catalog_name_lower.include?("bios") && firmware_name_lower.include?("bios")
+      
+      # 3. Check identifiers
+      firmware_identifiers = extract_identifiers(firmware_name)
+      catalog_identifiers = extract_identifiers(catalog_name)
+      
+      return true if (firmware_identifiers & catalog_identifiers).any?
+      
+      # 4. Special case for network adapters
+      if (firmware_name_lower.include?("ethernet") || firmware_name_lower.include?("network")) &&
+         (catalog_name_lower.include?("ethernet") || catalog_name_lower.include?("network"))
+        return true
+      end
+      
+      # No match found
+      false
+    end
+    
+    def compare_versions(current_version, available_version)
+      # If versions are identical, no update needed
+      return false if current_version == available_version
+      
+      # If either version is N/A, no update available
+      return false if current_version == "N/A" || available_version == "N/A"
+      
+      # Try to handle Dell's version format (e.g., A00, A01, etc.)
+      if available_version.match?(/^[A-Z]\d+$/)
+        # If current version doesn't match Dell's format, assume update is needed
+        return true unless current_version.match?(/^[A-Z]\d+$/)
+        
+        # Compare Dell version format (A00 < A01 < A02 < ... < B00 < B01 ...)
+        available_letter = available_version[0]
+        available_number = available_version[1..-1].to_i
+        
+        current_letter = current_version[0]
+        current_number = current_version[1..-1].to_i
+        
+        return true if current_letter < available_letter
+        return true if current_letter == available_letter && current_number < available_number
+        return false
+      end
+      
+      # For numeric versions, try to compare them
+      if current_version.match?(/^[\d\.]+$/) && available_version.match?(/^[\d\.]+$/)
+        current_parts = current_version.split('.').map(&:to_i)
+        available_parts = available_version.split('.').map(&:to_i)
+        
+        # Compare each part of the version
+        max_length = [current_parts.length, available_parts.length].max
+        max_length.times do |i|
+          current_part = current_parts[i] || 0
+          available_part = available_parts[i] || 0
+          
+          return true if current_part < available_part
+          return false if current_part > available_part
+        end
+        
+        # If we get here, versions are equal
+        return false
+      end
+      
+      # If we can't determine, assume update is needed
+      true
+    end
+  end
+end 

data/lib/idrac/version.rb

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

data/lib/idrac.rb

@@ -10,21 +10,16 @@ require 'uri'
 require 'debug' if ENV['RUBY_ENV'] == 'development'
 
 require_relative "idrac/version"
+require_relative "idrac/error"
 require_relative "idrac/client"
 require_relative "idrac/screenshot"
 require_relative "idrac/firmware"
+require_relative "idrac/firmware_catalog"
 
 module IDRAC
   class Error < StandardError; end
   
-  def self.new(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: true)
-    Client.new(
-      host: host,
-      username: username,
-      password: password,
-      port: port,
-      use_ssl: use_ssl,
-      verify_ssl: verify_ssl
-    )
+  def self.new(options = {})
+    Client.new(options)
   end
 end

data/test_firmware_update.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require_relative 'lib/idrac'
+
+# Create a client
+client = IDRAC::Client.new(
+  host: '127.0.0.1',
+  username: 'root',
+  password: 'calvin',
+  verify_ssl: false
+)
+
+begin
+  # Login to iDRAC
+  client.login
+  puts "Logged in successfully"
+  
+  # Create a firmware instance
+  firmware = IDRAC::Firmware.new(client)
+  
+  # Get system inventory
+  puts "Getting system inventory..."
+  inventory = firmware.get_system_inventory
+  
+  puts "System Information:"
+  puts "  Model: #{inventory[:system][:model]}"
+  puts "  Manufacturer: #{inventory[:system][:manufacturer]}"
+  puts "  Service Tag: #{inventory[:system][:service_tag]}"
+  puts "  BIOS Version: #{inventory[:system][:bios_version]}"
+  
+  puts "\nInstalled Firmware:"
+  inventory[:firmware].each do |fw|
+    puts "  #{fw[:name]}: #{fw[:version]} (#{fw[:updateable] ? 'Updateable' : 'Not Updateable'})"
+  end
+  
+  # Check for updates
+  catalog_path = File.expand_path("~/.idrac/Catalog.xml")
+  if File.exist?(catalog_path)
+    puts "\nChecking for updates using catalog: #{catalog_path}"
+    updates = firmware.check_updates(catalog_path)
+    
+    if updates.empty?
+      puts "No updates available."
+    else
+      puts "\nAvailable Updates:"
+      updates.each_with_index do |update, index|
+        puts "#{index + 1}. #{update[:name]}: #{update[:current_version]} -> #{update[:available_version]}"
+      end
+      
+      # For testing, select the first update
+      if updates.any?
+        selected_update = updates.first
+        puts "\nSelected update: #{selected_update[:name]}: #{selected_update[:current_version]} -> #{selected_update[:available_version]}"
+        
+        # Download and install the update
+        puts "Starting interactive update for selected component..."
+        firmware.interactive_update(catalog_path, [selected_update])
+      end
+    end
+  else
+    puts "\nCatalog file not found at #{catalog_path}. Please download the catalog first."
+  end
+  
+rescue IDRAC::Error => e
+  puts "Error: #{e.message}"
+ensure
+  # Logout
+  client.logout if client.instance_variable_get(:@session_id)
+  puts "Logged out"
+end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.1.26
+  version: 0.1.29
 platform: ruby
 authors:
 - Jonathan Siegel
@@ -209,10 +209,13 @@ files:
 - idrac.gemspec
 - lib/idrac.rb
 - lib/idrac/client.rb
+- lib/idrac/error.rb
 - lib/idrac/firmware.rb
+- lib/idrac/firmware_catalog.rb
 - lib/idrac/screenshot.rb
 - lib/idrac/version.rb
 - sig/idrac.rbs
+- test_firmware_update.rb
 homepage: http://github.com
 licenses:
 - MIT