idrac 0.1.24 → 0.1.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2e790b22ca375a798916fdb6d908583d2fa4823e90a814c2e7c27796c7b6351
-  data.tar.gz: 0ab7103ae540892dc959d22c7fa646050fe8eeaf003f6dc538c753fc3d614452
+  metadata.gz: 180bec6c43d2aced138c9479bbbfe23cec04c6149d2cd66343b5a738c0ce479f
+  data.tar.gz: 10fae4fc88a7d1ba456e3f7dc7d2efbfb8c7500b7839e7b59a2e27d5dae53c7c
 SHA512:
-  metadata.gz: 89b75cdaf04c90368379af12884e55dcd4e5daa52ccda59143776934c871a60c039891a13194a52496532159bad0859f3b8502fe2f8beeaf433319ba1d5aa0e1
-  data.tar.gz: 6dee9f26c047f9931ea846e2eaf738f91510801fdb090c384d18fd76639ca098db11ca071acb55ab81a0c319bb42ecb781d33f71ed83c66c9dac22c58c8bf2c6
+  metadata.gz: '0990d968c95f92c2b410b8338c88e8bff464089cc828f9bd49c2fa8bb8111aff7f059fc68d8ff958ccf9c2036af6aebcd2614b96b4ef757bbf93d59f47eecba5'
+  data.tar.gz: bfea9fe661ac565bc5ee652204a927a4c19977abef08bdd51ddf0c79027cc9f40c24d3b21522a9247d8933c22499f99b2bea73be02e0e647f81b42bf7ef2ec53

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,35 @@ 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
+- Fixed 415 Unsupported Media Type error by trying different content types
+- Added support for form-urlencoded requests when JSON requests fail
+- Enhanced error handling and logging during session creation
+
+### Version 0.1.25
+- **Enhanced Component Matching**: Improved firmware component matching with catalog entries
+- Added extraction of model numbers and identifiers from component names (X520, H730, etc.)
+- Implemented multiple matching strategies for better accuracy
+- Added special handling for different component types (NIC, PERC, BIOS, iDRAC, etc.)
+- Improved matching for components with different naming conventions
+
 ### Version 0.1.24
 - **Improved Firmware Update Check**: Fixed issues with firmware version comparison
 - Eliminated duplicate entries in firmware update results

data/bin/idrac

@@ -12,6 +12,23 @@ require "thor"
 require "idrac"
 
 module IDRAC
+  # Standalone catalog command that doesn't require a host
+  class CatalogCommand < Thor
+    desc "download [DIRECTORY]", "Download Dell firmware catalog"
+    def download(directory = nil)
+      # Create a FirmwareCatalog instance
+      catalog = IDRAC::FirmwareCatalog.new
+      
+      begin
+        catalog_path = catalog.download(directory)
+        puts "Catalog downloaded to: #{catalog_path}"
+      rescue IDRAC::Error => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+
   class CLI < Thor
     class_option :host, type: :string, required: true, desc: "iDRAC host address"
     class_option :username, type: :string, required: false, default: "root", desc: "iDRAC username (default: root)"
@@ -42,19 +59,8 @@ 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)
-      
-      begin
-        catalog_path = firmware.download_catalog(directory)
-        puts "Catalog downloaded to: #{catalog_path}"
-      rescue IDRAC::Error => e
-        puts "Error: #{e.message}"
-        exit 1
-      ensure
-        client.logout
-      end
+      # Forward to the catalog command
+      CatalogCommand.new.download(directory)
     end
     
     desc "firmware:status", "Show current firmware status and available updates"
@@ -85,20 +91,15 @@ 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'"
+          puts "\nTo check for updates, download the catalog first with 'idrac catalog download'"
         end
       rescue IDRAC::Error => e
         puts "Error: #{e.message}"
@@ -129,7 +130,8 @@ 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)
@@ -198,4 +200,18 @@ module IDRAC
   end
 end
 
-IDRAC::CLI.start(ARGV) 
+# Create a separate CLI class for commands that don't require a host
+module IDRAC
+  class StandaloneCLI < Thor
+    # Register the catalog command
+    desc "catalog", "Download Dell firmware catalog"
+    subcommand "catalog", CatalogCommand
+  end
+end
+
+# Check if the first argument is 'catalog'
+if ARGV[0] == 'catalog'
+  IDRAC::StandaloneCLI.start(ARGV)
+else
+  IDRAC::CLI.start(ARGV)
+end 

data/lib/idrac/client.rb

@@ -130,67 +130,120 @@ module IDRAC
       url = '/redfish/v1/SessionService/Sessions'
       payload = { "UserName" => username, "Password" => password }
       
-      # Use Basic Auth for the initial session creation
-      basic_auth_headers = {
-        'Authorization' => "Basic #{Base64.strict_encode64("#{username}:#{password}")}",
-        'Content-Type' => 'application/json'
-      }
-      
-      response = connection.post(url) do |req|
-        req.headers.merge!(basic_auth_headers)
-        req.body = payload.to_json
+      # Try first with just Content-Type header (no Basic Auth)
+      begin
+        response = connection.post(url) do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.body = payload.to_json
+        end
+        
+        if response.status == 201 || response.status == 200
+          # Extract X-Auth-Token from response headers
+          @x_auth_token = response.headers['X-Auth-Token']
+          
+          # Extract session location from response headers
+          @session_location = response.headers['Location']
+          
+          puts "Redfish session created successfully"
+          @sessions_maxed = false
+          return true
+        end
+      rescue => e
+        puts "First session creation attempt failed: #{e.message}"
       end
       
-      if response.status == 201 || response.status == 200
-        # Extract X-Auth-Token from response headers
-        @x_auth_token = response.headers['X-Auth-Token']
-        
-        # Extract session location from response headers
-        @session_location = response.headers['Location']
+      # If that fails, try with Basic Auth
+      begin
+        # Use Basic Auth for the session creation
+        basic_auth_headers = {
+          'Authorization' => "Basic #{Base64.strict_encode64("#{username}:#{password}")}",
+          'Content-Type' => 'application/json'
+        }
         
-        puts "Redfish session created successfully"
-        @sessions_maxed = false
-        return true
-      elsif response.status == 400 && response.body.include?("maximum number of user sessions")
-        puts "Maximum sessions reached during Redfish session creation"
-        @sessions_maxed = true
+        response = connection.post(url) do |req|
+          req.headers.merge!(basic_auth_headers)
+          req.body = payload.to_json
+        end
         
-        # Try to clear sessions if auto_delete_sessions is enabled
-        if @auto_delete_sessions
-          puts "Auto-delete sessions is enabled, attempting to clear sessions"
-          if force_clear_sessions
-            puts "Successfully cleared sessions, trying to create a new session"
-            
-            # Try one more time after clearing
+        if response.status == 201 || response.status == 200
+          # Extract X-Auth-Token from response headers
+          @x_auth_token = response.headers['X-Auth-Token']
+          
+          # Extract session location from response headers
+          @session_location = response.headers['Location']
+          
+          puts "Redfish session created successfully with Basic Auth"
+          @sessions_maxed = false
+          return true
+        elsif response.status == 400 && response.body.include?("maximum number of user sessions")
+          puts "Maximum sessions reached during Redfish session creation"
+          @sessions_maxed = true
+          
+          # Try to clear sessions if auto_delete_sessions is enabled
+          if @auto_delete_sessions
+            puts "Auto-delete sessions is enabled, attempting to clear sessions"
+            if force_clear_sessions
+              puts "Successfully cleared sessions, trying to create a new session"
+              
+              # Try one more time after clearing
+              response = connection.post(url) do |req|
+                req.headers.merge!(basic_auth_headers)
+                req.body = payload.to_json
+              end
+              
+              if response.status == 201 || response.status == 200
+                @x_auth_token = response.headers['X-Auth-Token']
+                @session_location = response.headers['Location']
+                puts "Redfish session created successfully after clearing sessions"
+                @sessions_maxed = false
+                return true
+              else
+                puts "Failed to create Redfish session after clearing: #{response.status} - #{response.body}"
+                # If we still can't create a session, switch to direct mode
+                @direct_mode = true
+                return false
+              end
+            else
+              puts "Failed to clear sessions, switching to direct mode"
+              @direct_mode = true
+              return false
+            end
+          else
+            puts "Auto-delete sessions is disabled, switching to direct mode"
+            @direct_mode = true
+            return false
+          end
+        else
+          puts "Failed to create Redfish session: #{response.status} - #{response.body}"
+          
+          # If we get a 415 error, try with form-urlencoded
+          if response.status == 415
+            puts "Trying with form-urlencoded content type"
             response = connection.post(url) do |req|
-              req.headers.merge!(basic_auth_headers)
-              req.body = payload.to_json
+              req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+              req.headers['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
+              req.body = "UserName=#{URI.encode_www_form_component(username)}&Password=#{URI.encode_www_form_component(password)}"
             end
             
             if response.status == 201 || response.status == 200
               @x_auth_token = response.headers['X-Auth-Token']
               @session_location = response.headers['Location']
-              puts "Redfish session created successfully after clearing sessions"
+              puts "Redfish session created successfully with form-urlencoded"
               @sessions_maxed = false
               return true
             else
-              puts "Failed to create Redfish session after clearing: #{response.status} - #{response.body}"
-              # If we still can't create a session, switch to direct mode
+              puts "Failed with form-urlencoded too: #{response.status} - #{response.body}"
               @direct_mode = true
               return false
             end
           else
-            puts "Failed to clear sessions, switching to direct mode"
             @direct_mode = true
             return false
           end
-        else
-          puts "Auto-delete sessions is disabled, switching to direct mode"
-          @direct_mode = true
-          return false
         end
-      else
-        puts "Failed to create Redfish session: #{response.status} - #{response.body}"
+      rescue => e
+        puts "Error during Redfish session creation: #{e.message}"
+        @direct_mode = true
         return false
       end
     end

data/lib/idrac/error.rb

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

data/lib/idrac/firmware.rb

@@ -5,6 +5,7 @@ require 'json'
 require 'nokogiri'
 require 'fileutils'
 require 'securerandom'
+require_relative 'firmware_catalog'
 
 module IDRAC
   class Firmware
@@ -22,6 +23,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 +41,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,74 +109,106 @@ 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.split.first)
       
-      # 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]
-        }
+      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
-        
-        # Check if this component matches any of our firmware
-        # We'll track if we found a match to avoid duplicates
-        matched = false
+      # 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 %-20s" % ["Component", "Current Version", "Available Version", "Updateable", "Category", "Status"]
+      puts "-" * 100
+      
+      # Process each firmware component
+      inventory[:firmware].each do |fw|
+        # Find matching updates in catalog
+        matching_updates = catalog_updates.select do |update|
+          catalog.match_component(fw[:name], update[:name])
+        end
         
-        current_versions.each do |id, fw_info|
-          # Normalize names for comparison
-          catalog_name = name.downcase.strip
-          firmware_name = fw_info[:name].downcase.strip
+        if matching_updates.any?
+          # Use the first matching update
+          update = matching_updates.first
           
-          # Check if names match or contain each other
-          if catalog_name.include?(firmware_name) || firmware_name.include?(catalog_name) ||
-             (catalog_name.include?("bios") && firmware_name.include?("bios"))
-            
-            # Skip if already matched to avoid duplicates
-            next if matched
+          # Check if version is newer
+          needs_update = catalog.compare_versions(fw[:version], update[:version])
+          
+          # Add to updates list if needed
+          if needs_update && fw[:updateable]
+            updates << {
+              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]
+            }
             
-            # Compare versions
-            if version != fw_info[:version] && fw_info[: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}"
-              }
-              
-              # Mark as matched to avoid duplicates
-              matched = true
-            end
+            # Print row with update available
+            puts "%-30s %-20s %-20s %-10s %-15s %-20s" % [
+              fw[:name][0..29],
+              fw[:version],
+              update[:version],
+              fw[:updateable] ? "Yes" : "No",
+              update[:category] || "N/A",
+              "UPDATE AVAILABLE"
+            ]
+          else
+            # Print row with no update available
+            puts "%-30s %-20s %-20s %-10s %-15s %-20s" % [
+              fw[:name][0..29],
+              fw[:version],
+              update[:version] || "N/A",
+              fw[:updateable] ? "Yes" : "No",
+              update[:category] || "N/A",
+              "No update available"
+            ]
           end
+        else
+          # No matching update found
+          puts "%-30s %-20s %-20s %-10s %-15s %-20s" % [
+            fw[:name][0..29],
+            fw[:version],
+            "N/A",
+            fw[:updateable] ? "Yes" : "No",
+            "N/A",
+            "No update available"
+          ]
         end
       end
       

data/lib/idrac/firmware_catalog.rb

@@ -0,0 +1,243 @@
+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 just the model number for PowerEdge servers (e.g., R640 from PowerEdge R640)
+      model_code = nil
+      if model_name.include?("PowerEdge")
+        model_code = model_name.split.last
+      end
+      
+      doc.xpath('//SupportedSystems/Brand/Model').each do |model|
+        name = model.at_xpath('Display')&.text
+        code = model.at_xpath('Code')&.text
+        
+        # Try to match by full name
+        if name && name.downcase.include?(model_name.downcase)
+          models << {
+            name: name,
+            code: code,
+            id: model['id']
+          }
+        # Try to match by model code (e.g., R640)
+        elsif model_code && code && code.downcase == model_code.downcase
+          models << {
+            name: name,
+            code: code,
+            id: model['id']
+          }
+        end
+      end
+      
+      models
+    end
+    
+    def find_updates_for_system(system_id)
+      doc = parse
+      updates = []
+      
+      doc.xpath("//SoftwareComponent[SupportedSystems/Brand/Model[@id='#{system_id}']]").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
+        category = component.at_xpath('Category')&.text
+        
+        next unless name && version && path
+        
+        updates << {
+          name: name,
+          version: version,
+          path: path,
+          component_type: component_type,
+          category: category,
+          download_url: "https://downloads.dell.com/#{path}"
+        }
+      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"
+      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.24"
+  VERSION = "0.1.28"
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.1.24
+  version: 0.1.28
 platform: ruby
 authors:
 - Jonathan Siegel
@@ -209,7 +209,9 @@ 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