idrac 0.1.26 → 0.1.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d751ffb6e590b80a6a5dc72457d8a4be11213224a13ebeae50698ae9f6cafff
-  data.tar.gz: 5a3f826850bf9aee8e40287ff7f8ab7c5bd71944ddce2b183dbe88dabed9c3fa
+  metadata.gz: 180bec6c43d2aced138c9479bbbfe23cec04c6149d2cd66343b5a738c0ce479f
+  data.tar.gz: 10fae4fc88a7d1ba456e3f7dc7d2efbfb8c7500b7839e7b59a2e27d5dae53c7c
 SHA512:
-  metadata.gz: 553bef804c000680be8ecadb15c19f2b4a335db5a7a44b5071ccb230f168880268e906f5a296a70c8659a5bbbb14a0ffb3a6f56cfc4c9ca216e0a1f8a6024a0f
-  data.tar.gz: ff4d0ce0967de6fbddd425844e0c86165276c44d508a2b8de41a20ec54e3998f7d2f1d5aa7cadf34201dd26113bd0abafb1e01d13439edbcb1d22f273e31a1f5
+  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,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

@@ -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/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,148 +109,112 @@ 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],
-          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
-        
-        # Extract identifiers from catalog component name for better matching
-        catalog_identifiers = extract_identifiers(name)
-        
-        # 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|
-          # 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
+        if matching_updates.any?
+          # Use the first matching update
+          update = matching_updates.first
           
-          # 1. Check if names contain each other
-          if catalog_name.include?(firmware_name) || firmware_name.include?(catalog_name)
-            match_found = true
-          end
-          
-          # 2. Check if BIOS components match
-          if (catalog_name.include?("bios") && firmware_name.include?("bios"))
-            match_found = true
-          end
+          # Check if version is newer
+          needs_update = catalog.compare_versions(fw[:version], update[:version])
           
-          # 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
-          
-          # 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 %-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
       
       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 interactive_update(catalog_path = nil)
       updates = check_updates(catalog_path)
       

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.26"
+  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.26
+  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