radfish 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f57d68f93828e6ae9d3721da829aa6c667660ce2995e5f133bb30b9575db4e0
-  data.tar.gz: 443f6020c0c9d017248044db6e4073c2144ef03c0856e2dc646a483dde1664e2
+  metadata.gz: b58ebe70659a5db047e1d6efb8c8ec93ba7a7cce19f500f46204add014095566
+  data.tar.gz: 754e9d84d9bc6232cadaa4daf75fa4053b3d0fa9d53918b2f1160223775c85f9
 SHA512:
-  metadata.gz: 1c7beb6bb2104a5955af53c23fcb3d61443996301b60b7b215fdbf3fd71a540e3aca19d43f8dc81fc8d8cb5af4ecf21edbfcdd580797707bfa1b748377bdba55
-  data.tar.gz: 5d352457420a2bc1c71bc6026eb36f847eda5929a611058acad25e43e07199bab22e699f8653c3e2e974505c9cea5ae786a555aaef7e99c7981c293dfcd996ea
+  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/cli.rb

@@ -377,6 +377,64 @@ module Radfish
       end
     end
     
+    # Network Commands
+    desc "network SUBCOMMAND", "BMC network configuration"
+    option :ip, desc: "IP address to set"
+    option :mask, desc: "Subnet mask"
+    option :gateway, desc: "Gateway address"
+    option :dns1, desc: "Primary DNS server"
+    option :dns2, desc: "Secondary DNS server"
+    option :hostname, desc: "BMC hostname"
+    def network(subcommand = 'show')
+      with_client do |client|
+        case subcommand
+        when 'show', 'get', 'status'
+          data = client.get_bmc_network
+          if options[:json]
+            puts JSON.pretty_generate(data)
+          else
+            puts "=== BMC Network Configuration ===".green
+            puts "IP Address:  #{data['ipv4_address']}".cyan
+            puts "Subnet Mask: #{data['subnet_mask']}".cyan
+            puts "Gateway:     #{data['gateway']}".cyan
+            puts "Mode:        #{data['mode']}".cyan
+            puts "MAC Address: #{data['mac_address']}".cyan
+            puts "Hostname:    #{data['hostname']}".cyan if data['hostname']
+            puts "FQDN:        #{data['fqdn']}".cyan if data['fqdn']
+            if data['dns_servers'] && !data['dns_servers'].empty?
+              puts "DNS Servers: #{data['dns_servers'].join(', ')}".cyan
+            end
+          end
+        when 'set', 'configure'
+          if !options[:ip] && !options[:hostname] && !options[:dns1]
+            error "Must provide at least --ip, --hostname, or --dns1"
+            return
+          end
+          
+          if options[:ip] && !options[:mask]
+            error "Must provide --mask when setting --ip"
+            return
+          end
+          
+          result = client.set_bmc_network(
+            ip_address: options[:ip],
+            subnet_mask: options[:mask],
+            gateway: options[:gateway],
+            dns_primary: options[:dns1],
+            dns_secondary: options[:dns2],
+            hostname: options[:hostname]
+          )
+          output_result({ success: result }, result ? "Network configured successfully" : "Failed to configure network")
+        when 'dhcp'
+          result = client.set_bmc_dhcp
+          output_result({ success: result }, result ? "BMC set to DHCP mode" : "Failed to set DHCP mode")
+        else
+          error "Unknown network command: #{subcommand}"
+          puts "Available: show, set, dhcp"
+        end
+      end
+    end
+    
     # Config Commands
     desc "config SUBCOMMAND", "Configuration file management"
     def config(subcommand = 'generate')

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/core/network.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    module Network
+      def get_bmc_network
+        raise NotImplementedError, "Adapter must implement #get_bmc_network"
+      end
+      
+      def set_bmc_network(ip_address: nil, subnet_mask: nil, gateway: nil, 
+                          dns_primary: nil, dns_secondary: nil, hostname: nil, 
+                          dhcp: false)
+        raise NotImplementedError, "Adapter must implement #set_bmc_network"
+      end
+      
+      def set_bmc_dhcp
+        # Convenience method that calls set_bmc_network with dhcp: true
+        set_bmc_network(dhcp: true)
+      end
+    end
+  end
+end

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.3"
+  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,18 +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/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.3
+  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,18 +165,25 @@ 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
 - lib/radfish/core/base_client.rb
 - lib/radfish/core/boot.rb
 - lib/radfish/core/jobs.rb
+- lib/radfish/core/network.rb
 - lib/radfish/core/power.rb
 - lib/radfish/core/session.rb
 - lib/radfish/core/storage.rb
 - 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