radfish 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fb2656b390f3016128a43472976efddf6593d7e30f3e498de88ed63122d6f75
-  data.tar.gz: 696317fe19cbceef762da5e5ab4dad28c0b8a1f923a5677fdfcfd551f84225d5
+  metadata.gz: b58ebe70659a5db047e1d6efb8c8ec93ba7a7cce19f500f46204add014095566
+  data.tar.gz: 754e9d84d9bc6232cadaa4daf75fa4053b3d0fa9d53918b2f1160223775c85f9
 SHA512:
-  metadata.gz: e9ba57f9683e6177abd5bce2481e3e4338e75b04769c160c20c5596094bea4a4b8b0e59fdca9a8473f350fcc2cab2d6d50a88f456f147ebdd23ea54cbe47f1f6
-  data.tar.gz: e51c1b2ec7fc3013fa65661868dbc9a1c655009f58f0c537966991b2575af45f72a72979cd78acf8b6d4902e5460689821bb524abbf95b97fb08c1d9e72029d1
+  metadata.gz: 4653a3eb7d252f6a597db65f4a403f1b5f958dc5659d9a0a0f4eb73f669acc9b3be6b0d61b2686e4666823769e4027cd6eb31429a29c130cf08ab9b28aa64b77
+  data.tar.gz: dc6f9ffc5dd25d59ee68d70ab0071378d3d6aa4c4004f13e612d31415c817bdf48bc70433f7344685fb34ac529397226883d9e24ecfb66e3ccfbb1b6f52d7307

data/README.md

@@ -2,6 +2,16 @@
 
 A Ruby client library that provides a unified interface for managing servers via Redfish API, with automatic vendor detection and adaptation.
 
+## Data Normalization
+
+Radfish takes a minimal approach to data normalization to ensure consistency across different systems and avoid mismatches from varying formats:
+
+- **Manufacturer/Make**: Returns simplified vendor names (e.g., "Dell" instead of "Dell Inc.", "Supermicro" instead of "Super Micro Computer")
+- **Model**: Returns core model identifiers without marketing prefixes (e.g., "R640" instead of "PowerEdge R640")
+- **Consistent Fields**: All adapters normalize their data to use the same field names and formats
+
+This approach minimizes potential mismatches across older systems or spacing/hyphenation issues with multi-token descriptors.
+
 ## Architecture
 
 Radfish provides a vendor-agnostic interface for server management through Redfish, automatically detecting and adapting to different hardware vendors. The architecture consists of:

data/lib/radfish/bmc_info.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Radfish
+  class BmcInfo
+    attr_reader :client
+    
+    def initialize(client)
+      @client = client
+      @cache = {}
+    end
+    
+    def keys
+      [:license_version, :firmware_version, :redfish_version, :mac_address, :ip_address, :hostname, :health]
+    end
+    
+    def to_h
+      keys.each_with_object({}) do |key, hash|
+        hash[key] = send(key)
+      end
+    end
+    
+    def license_version
+      fetch_bmc_info[:license_version] || fetch_bmc_info[:bmc_license_version]
+    end
+    
+    def firmware_version
+      fetch_bmc_info[:firmware_version] || fetch_bmc_info[:bmc_firmware_version]
+    end
+    
+    def redfish_version
+      fetch_bmc_info[:redfish_version]
+    end
+    
+    def mac_address
+      fetch_bmc_info[:mac_address] || fetch_bmc_info[:bmc_mac_address]
+    end
+    
+    def ip_address
+      fetch_bmc_info[:ip_address] || fetch_bmc_info[:bmc_ip_address]
+    end
+    
+    def hostname
+      fetch_bmc_info[:hostname] || fetch_bmc_info[:bmc_hostname]
+    end
+    
+    def health
+      fetch_bmc_info[:health] || fetch_bmc_info[:bmc_health]
+    end
+    
+    private
+    
+    def fetch_bmc_info
+      @cache[:bmc_info] ||= begin
+        if @client.adapter.respond_to?(:bmc_info)
+          @client.adapter.bmc_info
+        elsif @client.adapter.respond_to?(:system_info)
+          # Extract BMC-related info from system_info if no dedicated method
+          info = @client.adapter.system_info
+          {
+            firmware_version: info[:bmc_firmware_version] || info[:firmware_version],
+            license_version: info[:bmc_license_version] || info[:license_version],
+            redfish_version: info[:redfish_version],
+            mac_address: info[:bmc_mac_address],
+            ip_address: info[:bmc_ip_address],
+            hostname: info[:bmc_hostname],
+            health: info[:bmc_health]
+          }
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/radfish/client.rb

@@ -24,7 +24,7 @@ module Radfish
         @vendor = detector.detect
         
         if @vendor.nil?
-          raise UnsupportedVendorError, "Could not detect vendor for #{host}"
+          raise UnsupportedVendorError, "Could not detect vendor for #{host}:#{options[:port] || 443}. Please check: 1) The host is reachable, 2) Credentials are correct (#{username}), 3) The BMC supports Redfish API"
         end
         
         debug "Auto-detected vendor: #{@vendor}", 1, :green
@@ -113,6 +113,33 @@ module Radfish
       @adapter.class
     end
     
+    # Lazy-loading API methods that return structured data
+    
+    def system
+      @system ||= SystemInfo.new(self)
+    end
+    
+    def bmc
+      @bmc ||= BmcInfo.new(self)
+    end
+    
+    def power
+      @power ||= PowerInfo.new(self)
+    end
+    
+    def thermal
+      @thermal ||= ThermalInfo.new(self)
+    end
+    
+    def pci
+      @pci ||= PciInfo.new(self)
+    end
+    
+    def service_tag
+      # Get service_tag from system info
+      system.service_tag
+    end
+    
     def supported_features
       # Return a list of features this adapter supports
       features = []

data/lib/radfish/core/base_client.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'logger'
+
 module Radfish
   module Core
     class BaseClient
@@ -23,26 +25,49 @@ module Radfish
         
         # Store any vendor-specific options
         @options = options
+        
+        # Create the HTTP client
+        @http_client = HttpClient.new(
+          host: host,
+          port: port,
+          use_ssl: use_ssl,
+          verify_ssl: verify_ssl,
+          username: username,
+          password: password,
+          verbosity: verbosity,
+          retry_count: retry_count,
+          retry_delay: retry_delay
+        )
       end
       
       def base_url
-        protocol = use_ssl ? 'https' : 'http'
-        "#{protocol}://#{host}:#{port}"
-      end
-      
-      def connection
-        @connection ||= Faraday.new(url: base_url, ssl: { verify: verify_ssl }) do |faraday|
-          faraday.request :multipart
-          faraday.request :url_encoded
-          faraday.adapter Faraday.default_adapter
-          
-          if @verbosity > 0
-            faraday.response :logger, Logger.new(STDOUT), bodies: @verbosity >= 2 do |logger|
-              logger.filter(/(Authorization: Basic )([^,\n]+)/, '\1[FILTERED]')
-              logger.filter(/(Password"=>"?)([^,"]+)/, '\1[FILTERED]')
-            end
-          end
-        end
+        @http_client.base_url
+      end
+      
+      def verbosity=(value)
+        @verbosity = value
+        @http_client.verbosity = value if @http_client
+      end
+      
+      # Delegate HTTP methods to the client
+      def http_get(path, **options)
+        @http_client.get(path, **options)
+      end
+      
+      def http_post(path, **options)
+        @http_client.post(path, **options)
+      end
+      
+      def http_put(path, **options)
+        @http_client.put(path, **options)
+      end
+      
+      def http_patch(path, **options)
+        @http_client.patch(path, **options)
+      end
+      
+      def http_delete(path, **options)
+        @http_client.delete(path, **options)
       end
       
       def with_retries(max_retries = nil, initial_delay = nil, error_classes = nil)
@@ -104,6 +129,13 @@ module Radfish
         end
       end
       
+      protected
+      
+      # Access to the underlying HTTP client for subclasses
+      def http_client
+        @http_client
+      end
+      
       # Helper for handling responses
       def handle_response(response)
         if response.headers["location"]

data/lib/radfish/core/boot.rb

@@ -3,8 +3,8 @@
 module Radfish
   module Core
     module Boot
-      def boot_options
-        raise NotImplementedError, "Adapter must implement #boot_options"
+      def boot_config
+        raise NotImplementedError, "Adapter must implement #boot_config"
       end
       
       def set_boot_override(target, persistent: false)

data/lib/radfish/http_client.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'faraday/retry'
+require 'logger'
+
+module Radfish
+  # Shared HTTP client for all BMC connections
+  class HttpClient
+    include Debuggable
+    
+    attr_reader :host, :port, :use_ssl, :verify_ssl
+    attr_accessor :username, :password, :verbosity, :retry_count, :retry_delay
+    
+    def initialize(host:, port: 443, use_ssl: true, verify_ssl: false, 
+                   username: nil, password: nil, verbosity: 0,
+                   retry_count: 3, retry_delay: 1, **options)
+      @host = host
+      @port = port
+      @use_ssl = use_ssl
+      @verify_ssl = verify_ssl
+      @username = username
+      @password = password
+      @verbosity = verbosity
+      @retry_count = retry_count
+      @retry_delay = retry_delay
+      @options = options
+    end
+    
+    def base_url
+      protocol = use_ssl ? 'https' : 'http'
+      "#{protocol}://#{host}:#{port}"
+    end
+    
+    def get(path, headers: {}, **options)
+      request(:get, path, headers: headers, **options)
+    end
+    
+    def post(path, body: nil, headers: {}, **options)
+      request(:post, path, body: body, headers: headers, **options)
+    end
+    
+    def put(path, body: nil, headers: {}, **options)
+      request(:put, path, body: body, headers: headers, **options)
+    end
+    
+    def patch(path, body: nil, headers: {}, **options)
+      request(:patch, path, body: body, headers: headers, **options)
+    end
+    
+    def delete(path, headers: {}, **options)
+      request(:delete, path, headers: headers, **options)
+    end
+    
+    def request(method, path, body: nil, headers: {}, auth: true, timeout: nil, **options)
+      response = connection(auth: auth).send(method) do |req|
+        req.url path
+        req.headers.merge!(headers)
+        req.body = body if body
+        
+        # Override timeout if specified
+        if timeout
+          req.options.timeout = timeout
+          req.options.open_timeout = [timeout / 2, 5].min
+        end
+        
+        # Apply any additional options
+        options.each do |key, value|
+          req.options[key] = value if req.options.respond_to?(:"#{key}=")
+        end
+      end
+      
+      response
+    rescue Faraday::ConnectionFailed => e
+      debug "Connection failed: #{e.message}", 1, :red
+      raise ConnectionError, "Failed to connect to #{host}: #{e.message}"
+    rescue Faraday::TimeoutError => e
+      debug "Request timed out: #{e.message}", 1, :red
+      raise TimeoutError, "Request to #{host} timed out: #{e.message}"
+    rescue Faraday::SSLError => e
+      debug "SSL error: #{e.message}", 1, :red
+      raise ConnectionError, "SSL error connecting to #{host}: #{e.message}"
+    rescue => e
+      debug "HTTP request failed: #{e.class} - #{e.message}", 1, :red
+      raise Error, "HTTP request failed: #{e.message}"
+    end
+    
+    private
+    
+    def connection(auth: true)
+      @connections ||= {}
+      cache_key = auth ? :with_auth : :without_auth
+      
+      @connections[cache_key] ||= Faraday.new(url: base_url, ssl: { verify: verify_ssl }) do |faraday|
+        # Add authentication if credentials provided and auth is enabled
+        if auth && username && password
+          faraday.request :authorization, :basic, username, password
+        end
+        
+        # Standard headers
+        faraday.headers['Accept'] = 'application/json'
+        faraday.headers['Content-Type'] = 'application/json'
+        faraday.headers['Connection'] = 'keep-alive'
+        
+        # Enable multipart for file uploads
+        faraday.request :multipart
+        faraday.request :url_encoded
+        
+        # Add retry middleware for robustness
+        faraday.request :retry, {
+          max: retry_count,
+          interval: retry_delay,
+          interval_randomness: 0.5,
+          backoff_factor: 2,
+          exceptions: [
+            Faraday::ConnectionFailed,
+            Faraday::TimeoutError,
+            Faraday::RetriableResponse
+          ],
+          methods: [:get, :put, :delete, :post, :patch],
+          retry_statuses: [408, 429, 500, 502, 503, 504],
+          retry_block: -> (env, options, retries, exception) {
+            if verbosity > 0
+              debug "Retry #{retries}/#{options[:max]}: #{exception&.message || "HTTP #{env.status}"}", 1, :yellow
+            end
+          }
+        }
+        
+        # Set timeouts
+        faraday.options.timeout = 30
+        faraday.options.open_timeout = 10
+        
+        # Add logging if verbose
+        if verbosity > 0
+          faraday.response :logger, Logger.new(STDOUT), bodies: verbosity >= 2 do |logger|
+            logger.filter(/(Authorization: Basic )([^,\n]+)/, '\1[FILTERED]')
+            logger.filter(/(Password"=>"?)([^,"]+)/, '\1[FILTERED]')
+            logger.filter(/("password":\s*")([^"]+)/, '\1[FILTERED]')
+          end
+        end
+        
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+  end
+end

data/lib/radfish/pci_info.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Radfish
+  class PciInfo
+    attr_reader :client
+    
+    def initialize(client)
+      @client = client
+      @cache = {}
+    end
+    
+    # Get all PCI devices
+    def devices
+      @cache[:devices] ||= @client.adapter.pci_devices
+    end
+    
+    # Get NICs with PCI slot information
+    def nics_with_slots
+      @cache[:nics_with_slots] ||= @client.adapter.nics_with_pci_info
+    end
+    
+    # Find PCI devices by manufacturer
+    def devices_by_manufacturer(manufacturer)
+      devices.select { |d| d.manufacturer&.match?(/#{manufacturer}/i) }
+    end
+    
+    # Find Mellanox devices
+    def mellanox_devices
+      devices_by_manufacturer('Mellanox')
+    end
+    
+    # Get network controllers
+    def network_controllers
+      devices.select { |d| d.device_class&.match?(/NetworkController/i) }
+    end
+  end
+end

data/lib/radfish/power_info.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Radfish
+  class PowerInfo
+    attr_reader :client
+    
+    def initialize(client)
+      @client = client
+      @cache = {}
+    end
+    
+    def keys
+      [:state, :usage_watts, :capacity_watts, :allocated_watts, :reset_types_allowed, :psus, :on, :off, :restart, :cycle]
+    end
+    
+    def to_h
+      # Only include data attributes, not methods
+      data_keys = [:state, :usage_watts, :capacity_watts, :allocated_watts, :reset_types_allowed, :psus]
+      data_keys.each_with_object({}) do |key, hash|
+        hash[key] = send(key) rescue nil
+      end
+    end
+    
+    def state
+      fetch_power_status[:power_state] || fetch_power_status[:state]
+    end
+    
+    def usage_watts
+      fetch_power_consumption[:consumed_watts] || 
+        fetch_power_consumption[:power_usage_watts] || 
+        fetch_power_consumption_watts
+    end
+    
+    def capacity_watts
+      fetch_power_consumption[:capacity_watts] || fetch_power_consumption[:power_capacity_watts]
+    end
+    
+    def allocated_watts
+      fetch_power_consumption[:allocated_watts] || fetch_power_consumption[:power_allocated_watts]
+    end
+    
+    def on
+      @client.adapter.power_on
+    end
+    
+    def off(force: false)
+      @client.adapter.power_off(force: force)
+    end
+    
+    def restart(force: false)
+      @client.adapter.power_restart(force: force)
+    end
+    
+    def cycle
+      @client.adapter.power_cycle
+    end
+    
+    def reset_types_allowed
+      @cache[:reset_types] ||= @client.adapter.reset_type_allowed if @client.adapter.respond_to?(:reset_type_allowed)
+    end
+    
+    def psus
+      @cache[:psus] ||= @client.adapter.psus
+    end
+    
+    private
+    
+    def fetch_power_status
+      @cache[:power_status] ||= begin
+        if @client.adapter.respond_to?(:power_status)
+          status = @client.adapter.power_status
+          case status
+          when Hash
+            status
+          when String, Symbol
+            { power_state: status.to_s }
+          else
+            { power_state: status }
+          end
+        else
+          {}
+        end
+      end
+    end
+    
+    def fetch_power_consumption
+      @cache[:power_consumption] ||= begin
+        if @client.adapter.respond_to?(:power_consumption)
+          @client.adapter.power_consumption
+        else
+          {}
+        end
+      end
+    end
+    
+    def fetch_power_consumption_watts
+      @cache[:power_consumption_watts] ||= begin
+        if @client.adapter.respond_to?(:power_consumption_watts)
+          @client.adapter.power_consumption_watts
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/radfish/system_info.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Radfish
+  class SystemInfo
+    attr_reader :client
+    
+    def initialize(client)
+      @client = client
+      @cache = {}
+    end
+    
+    def keys
+      [:service_tag, :make, :model, :serial, :cpus, :memory, :nics, :fans, :psus, :health, :controllers]
+    end
+    
+    def to_h
+      keys.each_with_object({}) do |key, hash|
+        hash[key] = send(key)
+      end
+    end
+    
+    def service_tag
+      fetch_system_info[:service_tag]
+    end
+    
+    def make
+      fetch_system_info[:manufacturer] || fetch_system_info[:make]
+    end
+    
+    def model
+      fetch_system_info[:model]
+    end
+    
+    def serial
+      fetch_system_info[:serial_number] || fetch_system_info[:serial]
+    end
+    
+    def cpus
+      @cache[:cpus] ||= @client.adapter.cpus
+    end
+    
+    def memory
+      @cache[:memory] ||= @client.adapter.memory
+    end
+    
+    def nics
+      @cache[:nics] ||= @client.adapter.nics
+    end
+    
+    def fans
+      @cache[:fans] ||= @client.adapter.fans
+    end
+    
+    # Removed temperatures - not universally supported
+    
+    def psus
+      @cache[:psus] ||= @client.adapter.psus
+    end
+    
+    def health
+      @cache[:health] ||= @client.adapter.system_health
+    end
+    
+    def controllers
+      @cache[:controllers] ||= @client.adapter.storage_controllers
+    end
+    
+    private
+    
+    def fetch_system_info
+      @cache[:system_info] ||= @client.adapter.system_info
+    end
+  end
+end

data/lib/radfish/thermal_info.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Radfish
+  class ThermalInfo
+    attr_reader :client
+    
+    def initialize(client)
+      @client = client
+      @cache = {}
+    end
+    
+    def keys
+      [:fans]
+    end
+    
+    def to_h
+      keys.each_with_object({}) do |key, hash|
+        hash[key] = send(key) rescue nil
+      end
+    end
+    
+    def fans
+      @cache[:fans] ||= @client.adapter.fans
+    end
+  end
+end

data/lib/radfish/vendor_detector.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require 'net/http'
 require 'json'
-require 'uri'
-require 'openssl'
 
 module Radfish
   class VendorDetector
+    include Debuggable
     
     attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl
     attr_accessor :verbosity
@@ -19,17 +17,39 @@ module Radfish
       @use_ssl = use_ssl
       @verify_ssl = verify_ssl
       @verbosity = 0
+      
+      # Use the shared HTTP client
+      @http_client = HttpClient.new(
+        host: host,
+        port: port,
+        use_ssl: use_ssl,
+        verify_ssl: verify_ssl,
+        username: username,
+        password: password,
+        verbosity: 0,  # Will be updated via verbosity= setter
+        retry_count: 2,  # Fewer retries for detection
+        retry_delay: 0.5
+      )
+    end
+    
+    def verbosity=(value)
+      @verbosity = value
+      @http_client.verbosity = value if @http_client
     end
     
     def detect
-      puts "Detecting vendor for #{host}..." if @verbosity && @verbosity > 0
+      debug "Detecting vendor for #{host}:#{port}...", 1, :cyan
       
       # Try to get the Redfish service root
       service_root = fetch_service_root
-      return nil unless service_root
+      
+      unless service_root
+        debug "Failed to fetch service root from #{host}:#{port}", 1, :red
+        return nil
+      end
       
       vendor = identify_vendor(service_root)
-      puts "Detected vendor: #{vendor || 'Unknown'}" if @verbosity && @verbosity > 0
+      debug "Detected vendor: #{vendor || 'Unknown'} for #{host}:#{port}", 1, vendor ? :green : :yellow
       
       vendor
     end
@@ -37,29 +57,38 @@ module Radfish
     private
     
     def fetch_service_root
-      uri = URI("#{base_url}/redfish/v1")
-      
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = use_ssl
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless verify_ssl
-      http.open_timeout = 5
-      http.read_timeout = 10
-      
-      req = Net::HTTP::Get.new(uri)
-      req.basic_auth(username, password)
-      req['Accept'] = 'application/json'
-      
       begin
-        res = http.request(req)
+        # Use a shorter timeout for vendor detection (5 seconds total)
+        response = @http_client.get('/redfish/v1', timeout: 5)
         
-        if res.code.to_i == 200
-          JSON.parse(res.body)
+        if response.status == 200
+          JSON.parse(response.body)
+        elsif response.status == 401
+          debug "Authentication failed (HTTP 401) - check username/password", 1, :red
+          nil
+        elsif response.status == 404
+          debug "Redfish API not found at /redfish/v1 (HTTP 404)", 1, :red
+          nil
         else
-          puts "Failed to fetch service root: HTTP #{res.code}" if @verbosity && @verbosity > 0
+          debug "Failed to fetch service root: HTTP #{response.status}", 1, :red
+          debug "Response body: #{response.body[0..200]}" if response.body && @verbosity >= 2
           nil
         end
+      rescue ConnectionError, TimeoutError => e
+        debug "Connection failed to #{host}:#{port} - #{e.message}", 1, :red
+        nil
+      rescue JSON::ParserError => e
+        debug "Invalid JSON response from BMC: #{e.message}", 1, :red
+        nil
+      rescue Faraday::ConnectionFailed => e
+        debug "Connection refused or failed to #{host}:#{port} - #{e.message}", 1, :red
+        nil
+      rescue Faraday::TimeoutError => e
+        debug "Request timed out to #{host}:#{port} - #{e.message}", 1, :red
+        nil
       rescue => e
-        puts "Error fetching service root: #{e.message}" if @verbosity && @verbosity > 0
+        debug "Unexpected error fetching service root: #{e.class} - #{e.message}", 1, :red
+        debug "Backtrace: #{e.backtrace.first(3).join("\n")}" if @verbosity >= 2
         nil
       end
     end
@@ -101,23 +130,11 @@ module Radfish
     end
     
     def detect_from_managers(managers_path)
-      uri = URI("#{base_url}#{managers_path}")
-      
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = use_ssl
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless verify_ssl
-      http.open_timeout = 5
-      http.read_timeout = 10
-      
-      req = Net::HTTP::Get.new(uri)
-      req.basic_auth(username, password)
-      req['Accept'] = 'application/json'
-      
       begin
-        res = http.request(req)
+        response = @http_client.get(managers_path)
         
-        if res.code.to_i == 200
-          data = JSON.parse(res.body)
+        if response.status == 200
+          data = JSON.parse(response.body)
           
           # Check first manager
           if data['Members'] && data['Members'].first
@@ -135,7 +152,6 @@ module Radfish
               # Check manager model/description
               model = manager_data['Model'] || ''
               description = manager_data['Description'] || ''
-              # firmware = manager_data['FirmwareVersion'] || ''  # Reserved for future use
               
               return 'dell' if model.match?(/idrac/i) || description.match?(/idrac/i)
               return 'hpe' if model.match?(/ilo/i) || description.match?(/ilo/i)
@@ -146,30 +162,18 @@ module Radfish
           end
         end
       rescue => e
-        puts "Error detecting from managers: #{e.message}" if @verbosity && @verbosity > 1
+        debug "Error detecting from managers: #{e.message}", 3, :yellow
       end
       
       nil
     end
     
     def fetch_manager(manager_path)
-      uri = URI("#{base_url}#{manager_path}")
-      
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = use_ssl
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless verify_ssl
-      http.open_timeout = 5
-      http.read_timeout = 10
-      
-      req = Net::HTTP::Get.new(uri)
-      req.basic_auth(username, password)
-      req['Accept'] = 'application/json'
-      
       begin
-        res = http.request(req)
-        JSON.parse(res.body) if res.code.to_i == 200
+        response = @http_client.get(manager_path)
+        JSON.parse(response.body) if response.status == 200
       rescue => e
-        puts "Error fetching manager: #{e.message}" if @verbosity && @verbosity > 1
+        debug "Error fetching manager: #{e.message}", 3, :yellow
         nil
       end
     end
@@ -190,10 +194,5 @@ module Radfish
         vendor_string.to_s.downcase
       end
     end
-    
-    def base_url
-      protocol = use_ssl ? 'https' : 'http'
-      "#{protocol}://#{host}:#{port}"
-    end
   end
 end

data/lib/radfish/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Radfish
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/radfish.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'httparty'
 require 'faraday'
 require 'faraday/multipart'
+require 'faraday/retry'
 require 'base64'
 require 'uri'
 require 'json'
@@ -17,6 +17,18 @@ module Radfish
   class NotFoundError < Error; end
   class TimeoutError < Error; end
   class UnsupportedVendorError < Error; end
+  
+  # Virtual Media specific errors
+  class VirtualMediaError < Error; end
+  class VirtualMediaNotFoundError < VirtualMediaError; end
+  class VirtualMediaConnectionError < VirtualMediaError; end
+  class VirtualMediaLicenseError < VirtualMediaError; end
+  class VirtualMediaBusyError < VirtualMediaError; end
+  
+  # Task/Job errors
+  class TaskError < Error; end
+  class TaskTimeoutError < TaskError; end
+  class TaskFailedError < TaskError; end
 
   module Debuggable
     def debug(message, level = 1, color = :light_cyan)
@@ -62,19 +74,25 @@ module Radfish
   end
 end
 
-require 'radfish/version'
-require 'radfish/core/base_client'
-require 'radfish/core/session'
-require 'radfish/core/power'
-require 'radfish/core/system'
-require 'radfish/core/storage'
-require 'radfish/core/virtual_media'
-require 'radfish/core/boot'
-require 'radfish/core/jobs'
-require 'radfish/core/utility'
-require 'radfish/core/network'
-require 'radfish/vendor_detector'
-require 'radfish/client'
+require_relative 'radfish/version'
+require_relative 'radfish/http_client'
+require_relative 'radfish/core/base_client'
+require_relative 'radfish/core/session'
+require_relative 'radfish/core/power'
+require_relative 'radfish/core/system'
+require_relative 'radfish/core/storage'
+require_relative 'radfish/core/virtual_media'
+require_relative 'radfish/core/boot'
+require_relative 'radfish/core/jobs'
+require_relative 'radfish/core/utility'
+require_relative 'radfish/core/network'
+require_relative 'radfish/vendor_detector'
+require_relative 'radfish/system_info'
+require_relative 'radfish/bmc_info'
+require_relative 'radfish/power_info'
+require_relative 'radfish/thermal_info'
+require_relative 'radfish/pci_info'
+require_relative 'radfish/client'
 
 # Auto-load adapters if available
 begin

data/radfish.gemspec

@@ -29,9 +29,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor", "~> 1.2"
-  spec.add_dependency "httparty", "~> 0.21"
   spec.add_dependency "faraday", "~> 2.0"
   spec.add_dependency "faraday-multipart", "~> 1.0"
+  spec.add_dependency "faraday-retry", "~> 2.0"
   spec.add_dependency "nokogiri", "~> 1.14"
   spec.add_dependency "colorize", ">= 0.8"
   spec.add_dependency "activesupport", ">= 7.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: radfish
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Jonathan Siegel
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-28 00:00:00.000000000 Z
+date: 2025-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -25,47 +25,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: faraday-multipart
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: faraday-multipart
+  name: faraday-retry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -165,6 +165,7 @@ files:
 - Rakefile
 - exe/radfish
 - lib/radfish.rb
+- lib/radfish/bmc_info.rb
 - lib/radfish/cli.rb
 - lib/radfish/cli/base.rb
 - lib/radfish/client.rb
@@ -178,6 +179,11 @@ files:
 - lib/radfish/core/system.rb
 - lib/radfish/core/utility.rb
 - lib/radfish/core/virtual_media.rb
+- lib/radfish/http_client.rb
+- lib/radfish/pci_info.rb
+- lib/radfish/power_info.rb
+- lib/radfish/system_info.rb
+- lib/radfish/thermal_info.rb
 - lib/radfish/vendor_detector.rb
 - lib/radfish/version.rb
 - radfish.gemspec