idrac 0.9.3 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f284844e8559e5cb1873cc31e8f08bdff27f358f6b9c74e3cef2d41913ba96
-  data.tar.gz: 02db8a1bdc940f6a345db7543dd8b3d3cb5e1b3ac16efaa63bf0e35a369f4271
+  metadata.gz: cc0edda7bbcbf4e86782d914c909557f3bf6f24e5fa40284761f0e8d550c18b5
+  data.tar.gz: c8e3b1fa48d0eba346ab6d3410894e7ecce6c211c5f8719653c99bb384222e9e
 SHA512:
-  metadata.gz: 9151c3a3dbbf5be669d9482f5d24af9f0313f97b8fac83262c32b780bc641aeb93d1c3fbee2eeefbff8ea60006ce766b6fa0921e52a01bfcebf40142889f5a1a
-  data.tar.gz: 79d18056308f3e4255bd19f5003d38aec5ed05c8a20222d6ce07e0bb230eeaf139cd4d94d6f428a35e24c413785a045a2b6a4121660e11ada3213d5f565dad0d
+  metadata.gz: '059e0a01815b8b138f247a9a2698a415f342decd78f3a3bc2c028215a0e1d6b9bc415f3ba1e4b2badb53d598910061072e9016ca491d9bf47e63bb3935ef1c1d'
+  data.tar.gz: a72e06912c09d645b45ffa5ecb52c703489729a0c8cac87b7cef55117802b396138624f9171318d222eb56ed0defd9442b4d3a5e14d7874a62c0e57d194fa837

data/lib/idrac/client.rb

@@ -165,34 +165,33 @@ module IDRAC
       end
     end
 
+    # GET that returns parsed JSON on 200, nil on error. Never raises.
+    # Use for exploratory/optional endpoints that may not exist.
+    def safe_get(path)
+      response = authenticated_request(:get, path) { |r| r }
+      return nil unless response.status == 200
+      JSON.parse(response.body)
+    rescue
+      nil
+    end
+
     private
     
-    # Implementation of authenticated request without retry logic
-    def _perform_authenticated_request(method, path, options = {}, retry_count = 0)
-      # Check retry count to prevent infinite recursion
-      if retry_count >= @retry_count
-        debug "Maximum retry count reached", 1, :red
-        raise Error, "Failed to authenticate after #{@retry_count} retries"
-      end
-      
+    # Single-attempt authenticated request. Retry logic is in with_retries.
+    def _perform_authenticated_request(method, path, options = {})
       debug "Authenticated request: #{method.to_s.upcase} #{path}", 1
-      
-      # Extract options and prepare headers
+
       body = options[:body]
       headers = options[:headers] || {}
       timeout = options[:timeout]
       open_timeout = options[:open_timeout]
-      
+
       headers['User-Agent'] ||= 'iDRAC Ruby Client'
       headers['Accept'] ||= 'application/json'
       headers['Host'] = @host_header if @host_header
-      
-      # Debug the body being sent
-      if body && @verbosity >= 2
-        debug "Request body: #{body}", 2
-      end
-      
-      # Determine authentication method and set headers
+
+      debug "Request body: #{body}", 2 if body && @verbosity >= 2
+
       if @direct_mode
         headers['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
         debug "Using Basic Auth for request (direct mode)", 2
@@ -200,22 +199,22 @@ module IDRAC
         headers['X-Auth-Token'] = session.x_auth_token
         debug "Using X-Auth-Token for authentication", 2
       end
-      
-      # Make request with timeout handling
+
       response = make_request_with_timeouts(method, path, body, headers, timeout, open_timeout)
-      
-      # Handle authentication and connection errors
+
       case response.status
       when 401, 403
-        handle_auth_failure(method, path, options, retry_count)
+        handle_auth_failure(method, path, options, nil)
       else
         debug "Response status: #{response.status}", 2
         response
       end
     rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::SSLError => e
-      handle_connection_error(e, method, path, options, retry_count)
+      handle_connection_error(e, method, path, options, nil)
+    rescue IDRAC::Error
+      raise
     rescue => e
-      handle_general_error(e, method, path, options, retry_count)
+      handle_general_error(e, method, path, options, nil)
     end
     
     # Make request with timeout handling
@@ -241,56 +240,29 @@ module IDRAC
       end
     end
     
-    # Handle authentication failures
+    # Handle authentication failures — recreate session, then raise so with_retries retries
     def handle_auth_failure(method, path, options, retry_count)
-      if @direct_mode
-        debug "Authentication failed in direct mode, retrying...", 1, :light_yellow
-        sleep(retry_count + 1)
-        return _perform_authenticated_request(method, path, options, retry_count + 1)
-      else
-        debug "Session expired, creating new session...", 1, :light_yellow
-        session.delete if session.x_auth_token
-        
-        if session.create
-          debug "New session created, retrying request...", 1, :green
-          return _perform_authenticated_request(method, path, options, retry_count + 1)
-        else
-          debug "Session creation failed, falling back to direct mode...", 1, :light_yellow
-          @direct_mode = true
-          return _perform_authenticated_request(method, path, options, retry_count + 1)
-        end
+      debug "Authentication failed (401/403), recreating session...", 1, :light_yellow
+      session.delete if session.x_auth_token
+
+      unless session.create
+        debug "Session creation failed, falling back to direct mode", 1, :light_yellow
+        @direct_mode = true
       end
+
+      raise Error, "Authentication failed, session recreated"
     end
     
-    # Handle connection errors
+    # Handle connection errors — raise so with_retries can handle retry logic
     def handle_connection_error(error, method, path, options, retry_count)
       debug "Connection error: #{error.message}", 1, :red
-      sleep(retry_count + 1)
-      
-      if @direct_mode || session.x_auth_token
-        return _perform_authenticated_request(method, path, options, retry_count + 1)
-      elsif session.create
-        debug "Created new session after connection error", 1, :green
-        return _perform_authenticated_request(method, path, options, retry_count + 1)
-      else
-        @direct_mode = true
-        return _perform_authenticated_request(method, path, options, retry_count + 1)
-      end
+      raise Error, "Connection failed: #{error.message}"
     end
-    
-    # Handle general errors
+
+    # Handle general errors — raise so with_retries can handle retry logic
     def handle_general_error(error, method, path, options, retry_count)
       debug "Error during request: #{error.message}", 1, :red
-      
-      if @direct_mode
-        raise Error, "Error during authenticated request: #{error.message}"
-      elsif session.create
-        debug "Created new session after error, retrying...", 1, :green
-        return _perform_authenticated_request(method, path, options, retry_count + 1)
-      else
-        @direct_mode = true
-        return _perform_authenticated_request(method, path, options, retry_count + 1)
-      end
+      raise Error, "Request failed: #{error.message}"
     end
 
     def _perform_get(path:, headers: {})

data/lib/idrac/license.rb

@@ -1,359 +1,125 @@
 module IDRAC
   module License
     # Gets the license information from the iDRAC
-    # @return [Hash] License details
+    # @return [Hash, nil] License details
     def license_info
-      # Try the standard license endpoint first (works in iDRAC 9+)
-      response = authenticated_request(:get, "/redfish/v1/LicenseService/Licenses")
-      
-      if response.status == 200
-        license_data = JSON.parse(response.body)
-        debug "License collection: #{license_data}", 2
-
-        # Check if there are any license entries
-        if !license_data["Members"] || license_data["Members"].empty?
-          debug "No licenses found", 1, :yellow
-          return try_dell_oem_license_path()
-        end
-
-        # Get the first license in the list
-        license_uri = license_data["Members"][0]["@odata.id"]
-        debug "Using license URI: #{license_uri}", 2
-
-        # Get detailed license information
-        license_response = authenticated_request(:get, license_uri)
-        if license_response.status != 200
-          debug "Failed to retrieve license details: #{license_response.status}", 1, :red
-          return try_dell_oem_license_path()
+      # Try standard endpoint first (iDRAC 9+)
+      if (data = safe_get("/redfish/v1/LicenseService/Licenses"))
+        if data["Members"]&.any?
+          license_uri = data["Members"][0]["@odata.id"]
+          return safe_get(license_uri) || try_dell_oem_license_path
         end
-
-        license_details = JSON.parse(license_response.body)
-        debug "License details: #{license_details}", 2
-
-        return license_details
-      else
-        # The endpoint is not available (probably iDRAC 8)
-        debug "Standard license endpoint failed: #{response.status}, trying Dell OEM path", 1, :yellow
-        return try_dell_oem_license_path()
       end
+
+      try_dell_oem_license_path
     end
 
-    # Extracts the iDRAC version from the license description or server header
-    # @return [Integer, nil] The license version (e.g. 9) or nil if not found
+    # Extracts the iDRAC generation (e.g. 8, 9) from license or server header
+    # @return [Integer, nil]
     def license_version
-      # Use memoization to cache the result and avoid multiple API calls
       @license_version ||= compute_license_version
     end
-    
-    # Clear the cached license version (useful if iDRAC state changes)
+
     def clear_license_version_cache
       @license_version = nil
     end
-    
+
     private
-    
+
     def compute_license_version
-      # First try to get from license info
       license = license_info
       if license
-        # Check the Description field, which often contains the version
-        # Example: "iDRAC9 Enterprise License"
-        if license["Description"]&.match(/iDRAC(\d+)/i)
-          version = license["Description"].match(/iDRAC(\d+)/i)[1].to_i
-          debug "Found license version from Description: #{version}", 1
-          return version
-        end
-
-        # Try alternative fields if Description didn't work
-        if license["Name"]&.match(/iDRAC(\d+)/i)
-          version = license["Name"].match(/iDRAC(\d+)/i)[1].to_i
-          debug "Found license version from Name: #{version}", 1
-          return version
-        end
-        
-        # For Dell OEM license response format
-        if license["LicenseDescription"]&.match(/iDRAC(\d+)/i)
-          version = license["LicenseDescription"].match(/iDRAC(\d+)/i)[1].to_i
-          debug "Found license version from LicenseDescription: #{version}", 1
-          return version
+        %w[Description Name LicenseDescription].each do |field|
+          if license[field]&.match(/iDRAC(\d+)/i)
+            return $1.to_i
+          end
         end
       end
-      
-      # If license info failed or didn't have version info, try to get from server header
-      # Make a simple request to check the server header (often contains iDRAC version)
-      response = authenticated_request(:get, "/redfish/v1")
-      if response.headers["server"] && response.headers["server"].match(/iDRAC\/(\d+)/i)
-        version = response.headers["server"].match(/iDRAC\/(\d+)/i)[1].to_i
-        debug "Found license version from server header: #{version}", 1
-        return version
+
+      # Fall back to server header
+      response = authenticated_request(:get, "/redfish/v1") { |r| r }
+      if response.headers["server"]&.match(/iDRAC\/(\d+)/i)
+        return $1.to_i
       end
-      
-      debug "Could not determine license version from license info or server header", 1, :yellow
+
       nil
     end
-    
-    # Attempt to get license information using Dell OEM extension path (for iDRAC 8)
-    # @return [Hash, nil] License info or nil if not found
+
     def try_dell_oem_license_path
-      # Try several potential Dell license paths (order matters - most likely first)
-      dell_license_paths = [
-        "/redfish/v1/Managers/iDRAC.Embedded.1/Oem/Dell/DellLicenseManagementService/Licenses",
-        "/redfish/v1/Managers/iDRAC.Embedded.1/Attributes", # iDRAC attributes might contain license info
-        "/redfish/v1/Managers/iDRAC.Embedded.1"             # Manager entity might have license info embedded
-      ]
-      
-      dell_license_paths.each do |path|
-        response = authenticated_request(:get, path)
-        
-        if response.status == 200
-          debug "Found valid Dell license path: #{path}", 2
-          data = JSON.parse(response.body)
-          
-          # Check for license info in this response based on the path
-          if path.include?("DellLicenseManagementService")
-            return handle_dell_license_service_response(data)
-          elsif path.include?("Attributes")
-            return handle_dell_attributes_response(data)
-          elsif path.include?("iDRAC.Embedded.1") && !path.include?("Attributes")
-            return handle_dell_manager_response(data)
+      # Try Dell OEM license service (iDRAC 8)
+      if (data = safe_get("/redfish/v1/Managers/iDRAC.Embedded.1/Oem/Dell/DellLicenseManagementService/Licenses"))
+        if data["Members"]&.any?
+          license_uri = data["Members"][0]["@odata.id"]
+          if (details = safe_get(license_uri))
+            return {
+              "Id" => details["EntitlementID"] || "iDRAC-License",
+              "Description" => details["LicenseDescription"] || "iDRAC License",
+              "Name" => details["LicenseDescription"] || "iDRAC License",
+              "LicenseType" => details["LicenseType"] || license_type_from(details["LicenseDescription"]),
+              "Status" => { "Health" => "OK" },
+              "Removable" => true
+            }
           end
-        else
-          debug "Dell path #{path} response status: #{response.status}", 3
         end
       end
-      
-      # If we couldn't find any API path that works, try the service tag detection method 
-      service_tag = get_service_tag
-      if service_tag
-        # Service tag is often used to indicate Enterprise licenses on Dell systems
-        license_type = determine_license_type()
-        return {
-          "Id" => "iDRAC-License",
-          "Description" => "iDRAC8 #{license_type} License",
-          "Name" => "iDRAC License",
-          "LicenseType" => license_type,
-          "Status" => { "Health" => "OK" },
-          "Removable" => false,
-          "EntitlementID" => service_tag # Dell often uses service tag as entitlement ID
-        }
-      end
-      
-      # Fall back to feature detection if all else fails
-      debug "All Dell OEM license paths failed, using fallback detection", 1, :yellow
-      return create_fallback_license_info()
-    end
-    
-    # Handle response from Dell License Management Service
-    def handle_dell_license_service_response(data)
-      # Check if there are any license entries
-      if !data["Members"] || data["Members"].empty?
-        debug "No licenses found in Dell OEM path", 1, :yellow
-        return create_fallback_license_info(use_basic: true)
-      end
-      
-      # Get the first license in the list
-      license_uri = data["Members"][0]["@odata.id"]
-      debug "Using Dell OEM license URI: #{license_uri}", 2
-      
-      # Get detailed license information
-      license_response = authenticated_request(:get, license_uri)
-      if license_response.status != 200
-        debug "Failed to retrieve Dell OEM license details: #{license_response.status}", 1, :red
-        return create_fallback_license_info(use_basic: true)
-      end
-      
-      dell_license = JSON.parse(license_response.body)
-      debug "Dell OEM license details: #{dell_license}", 2
-      
-      # Convert Dell OEM license format to standard format
-      license_info = {
-        "Id" => dell_license["EntitlementID"] || "iDRAC-License",
-        "Description" => dell_license["LicenseDescription"] || "iDRAC License",
-        "Name" => dell_license["LicenseDescription"] || "iDRAC License",
-        "LicenseType" => dell_license["LicenseType"] || get_license_type_from_description(dell_license["LicenseDescription"]),
-        "Status" => { "Health" => "OK" },
-        "Removable" => true
-      }
-      
-      return license_info
-    end
-    
-    # Handle response from Dell Manager attributes
-    def handle_dell_attributes_response(data)
-      # Look for license information in attributes
-      if data["Attributes"] && (
-          data["Attributes"]["LicensableDevice.1.LicenseInfo.1"] ||
-          data["Attributes"]["System.ServerOS.1.OSName"] ||
-          data["Attributes"]["iDRAC.Info.1.LicensingInfo"]
-        )
-        
-        license_info = data["Attributes"]["LicensableDevice.1.LicenseInfo.1"] || 
-                       data["Attributes"]["iDRAC.Info.1.LicensingInfo"]
-        
-        if license_info
-          license_type = license_info.include?("Enterprise") ? "Enterprise" : 
-                         license_info.include?("Express") ? "Express" : "Basic"
-          
-          return {
-            "Id" => "iDRAC-License",
-            "Description" => "iDRAC8 #{license_type} License",
-            "Name" => "iDRAC License",
-            "LicenseType" => license_type,
-            "Status" => { "Health" => "OK" },
-            "Removable" => false
-          }
-        end
+
+      # Try manager attributes
+      if (data = safe_get("/redfish/v1/Managers/iDRAC.Embedded.1/Attributes"))
+        attr = data.dig("Attributes", "LicensableDevice.1.LicenseInfo.1") ||
+               data.dig("Attributes", "iDRAC.Info.1.LicensingInfo")
+        return build_license_hash(license_type_from(attr)) if attr
       end
-      
-      # If no license attributes found, fall back to feature detection
-      license_type = determine_license_type()
-      return {
-        "Id" => "iDRAC-License",
-        "Description" => "iDRAC8 #{license_type} License",
-        "Name" => "iDRAC License",
-        "LicenseType" => license_type,
-        "Status" => { "Health" => "OK" },
-        "Removable" => false
-      }
-    end
-    
-    # Handle response from Dell Manager entity
-    def handle_dell_manager_response(data)
-      # Look for license information in Oem data
-      if data["Oem"] && data["Oem"]["Dell"]
-        dell_data = data["Oem"]["Dell"]
-        
-        if dell_data["DellLicenseManagementService"]
-          # Found license service reference, but need to query it directly
-          service_uri = dell_data["DellLicenseManagementService"]["@odata.id"]
-          debug "Found license service URI: #{service_uri}", 2
-          
-          service_response = authenticated_request(:get, service_uri)
-          if service_response.status == 200
-            return handle_dell_license_service_response(JSON.parse(service_response.body))
+
+      # Try manager entity OEM data
+      if (data = safe_get("/redfish/v1/Managers/iDRAC.Embedded.1"))
+        if (service_uri = data.dig("Oem", "Dell", "DellLicenseManagementService", "@odata.id"))
+          if (svc_data = safe_get(service_uri)) && svc_data["Members"]&.any?
+            if (details = safe_get(svc_data["Members"][0]["@odata.id"]))
+              return {
+                "Id" => details["EntitlementID"] || "iDRAC-License",
+                "Description" => details["LicenseDescription"] || "iDRAC License",
+                "Name" => details["LicenseDescription"] || "iDRAC License",
+                "LicenseType" => details["LicenseType"] || license_type_from(details["LicenseDescription"]),
+                "Status" => { "Health" => "OK" },
+                "Removable" => true
+              }
+            end
           end
         end
-        
-        # Check if license info is embedded directly
+
+        dell_data = data.dig("Oem", "Dell") || {}
         if dell_data["LicenseType"] || dell_data["License"]
-          license_type = dell_data["LicenseType"] || 
-                        (dell_data["License"] && dell_data["License"].include?("Enterprise") ? "Enterprise" : 
-                         dell_data["License"].include?("Express") ? "Express" : "Basic")
-          
-          return {
-            "Id" => "iDRAC-License",
-            "Description" => "iDRAC8 #{license_type} License",
-            "Name" => "iDRAC License",
-            "LicenseType" => license_type,
-            "Status" => { "Health" => "OK" },
-            "Removable" => false
-          }
-        end
-      end
-      
-      # Check for license type in model name or description
-      if data["Model"] && data["Model"].include?("Enterprise")
-        return {
-          "Id" => "iDRAC-License",
-          "Description" => "iDRAC8 Enterprise License",
-          "Name" => "iDRAC License",
-          "LicenseType" => "Enterprise",
-          "Status" => { "Health" => "OK" },
-          "Removable" => false
-        }
-      end
-      
-      # If no license info found in manager data, fall back to feature detection
-      license_type = determine_license_type()
-      return {
-        "Id" => "iDRAC-License",
-        "Description" => "iDRAC8 #{license_type} License",
-        "Name" => "iDRAC License",
-        "LicenseType" => license_type,
-        "Status" => { "Health" => "OK" },
-        "Removable" => false
-      }
-    end
-    
-    # Get service tag from system info
-    def get_service_tag
-      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1")
-      if response.status == 200
-        data = JSON.parse(response.body)
-        return data["SKU"] if data["SKU"] # Service tag is usually in SKU field
-      end
-      
-      # Try alternate location
-      response = authenticated_request(:get, "/redfish/v1")
-      if response.status == 200
-        data = JSON.parse(response.body)
-        if data["Oem"] && data["Oem"]["Dell"] && data["Oem"]["Dell"]["ServiceTag"]
-          return data["Oem"]["Dell"]["ServiceTag"]
+          return build_license_hash(license_type_from(dell_data["LicenseType"] || dell_data["License"]))
         end
       end
-      
-      nil
+
+      # Last resort: detect from features
+      build_license_hash(detect_license_type)
     end
-    
-    # Helper method to extract license type from description
-    def get_license_type_from_description(description)
-      return "Unknown" unless description
-      
-      if description.include?("Enterprise")
-        return "Enterprise"
-      elsif description.include?("Express")
-        return "Express"
-      elsif description.include?("Datacenter")
-        return "Datacenter"
-      else
-        return "Basic"
-      end
+
+    def license_type_from(str)
+      return "Unknown" unless str
+      return "Enterprise" if str.include?("Enterprise")
+      return "Datacenter" if str.include?("Datacenter")
+      return "Express" if str.include?("Express")
+      "Basic"
     end
-    
-    # Creates a basic license info object based on system information
-    # Used as a fallback when neither the standard nor Dell OEM endpoints work
-    # @return [Hash] A basic license info object
-    def create_fallback_license_info(use_basic: false)
-      # Get the iDRAC version number from server headers
-      version = nil
-      response = authenticated_request(:get, "/redfish/v1")
-      if response.headers["server"] && response.headers["server"].match(/iDRAC\/(\d+)/i)
-        version = response.headers["server"].match(/iDRAC\/(\d+)/i)[1].to_i
-      end
-      
-      # Try to determine if it's Enterprise or Express based on available features
-      license_type = use_basic ? "Basic" : determine_license_type
-      
-      license_info = {
+
+    def build_license_hash(type)
+      {
         "Id" => "iDRAC-License",
-        "Description" => version ? "iDRAC#{version} #{license_type} License" : "iDRAC License",
+        "Description" => "iDRAC #{type} License",
         "Name" => "iDRAC License",
-        "LicenseType" => license_type,
+        "LicenseType" => type,
         "Status" => { "Health" => "OK" },
         "Removable" => false
       }
-      
-      debug "Created fallback license info: #{license_info}", 2
-      license_info
     end
-    
-    # Attempt to determine the license type (Enterprise/Express) based on available features
-    # @return [String] The license type (Enterprise, Express, or Basic)
-    def determine_license_type
-      # We can try to check for features only available in Enterprise
-      begin
-        # For example, virtual media is typically an Enterprise feature
-        virtual_media_response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/VirtualMedia")
-        # If we successfully get virtual media, it's likely Enterprise
-        if virtual_media_response.status == 200
-          return "Enterprise" 
-        end
-      rescue
-        # If the request fails, don't fail the whole method
-      end
-      
-      # Default to basic license if we can't determine
-      return "Express"
+
+    def detect_license_type
+      # Virtual media is typically Enterprise-only
+      data = safe_get("/redfish/v1/Managers/iDRAC.Embedded.1/VirtualMedia")
+      data ? "Enterprise" : "Express"
     end
   end
-end 
+end

data/lib/idrac/system.rb

@@ -314,161 +314,80 @@ module IDRAC
 
     # Get PCI device information
     def pci_devices
-      # First try the standard PCIeDevices endpoint
-      response = authenticated_request(:get, "/redfish/v1/Chassis/System.Embedded.1/PCIeDevices?$expand=*($levels=1)")
-      
-      if response.status == 200
-        begin
-          data = JSON.parse(response.body)
-          
-          pci = data["Members"].map do |stub|
-            manufacturer = stub["Manufacturer"]
-            
-            # Get PCIe function details if available
-            pcie_function = nil
-            if stub.dig("Links", "PCIeFunctions", 0, "@odata.id")
-              pcie_function_path = stub.dig("Links", "PCIeFunctions", 0, "@odata.id").split("v1/").last
-              function_response = authenticated_request(:get, "/redfish/v1/#{pcie_function_path}")
-              
-              if function_response.status == 200
-                pcie_function = JSON.parse(function_response.body)
-              end
-            end
-            
-            # Create device info with available data
-            device_info = {
-              "device_class" => pcie_function ? pcie_function["DeviceClass"] : nil,
-              "manufacturer" => manufacturer,
-              "name" => stub["Name"],
-              "description" => stub["Description"],
-              "id" => pcie_function ? pcie_function["Id"] : stub["Id"],
-              "slot_type" => pcie_function ? pcie_function.dig("Oem", "Dell", "DellPCIeFunction", "SlotType") : nil,
-              "bus_width" => pcie_function ? pcie_function.dig("Oem", "Dell", "DellPCIeFunction", "DataBusWidth") : nil,
-              "nic" => pcie_function ? pcie_function.dig("Links", "EthernetInterfaces", 0, "@odata.id") : nil
-            }
-            
-            puts "PCI Device: #{device_info["name"]} > #{device_info["manufacturer"]} > #{device_info["device_class"]} > #{device_info["description"]} > #{device_info["id"]}"
-            
-            device_info
-          end
-          
-          return pci
-        rescue JSON::ParserError
-          raise Error, "Failed to parse PCI devices response: #{response.body}"
-        end
-      else
-        # For iDRAC 8, try Dell's recommended approach using System endpoint with PCIeDevices select option
-        system_pcie_response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1?$select=PCIeDevices")
-        
-        if system_pcie_response.status == 200
-          begin 
-            system_data = JSON.parse(system_pcie_response.body)
-            
-            if system_data.key?("PCIeDevices") && !system_data["PCIeDevices"].empty?
-              pci_devices = []
-              
-              # Process each PCIe device
-              system_data["PCIeDevices"].each do |device_link|
-                if device_link.is_a?(Hash) && device_link["@odata.id"]
-                  device_path = device_link["@odata.id"]
-                  device_response = authenticated_request(:get, device_path)
-                  
-                  if device_response.status == 200
-                    device_data = JSON.parse(device_response.body)
-                    
-                    pci_devices << {
-                      "device_class" => device_data["DeviceType"] || "Unknown",
-                      "manufacturer" => device_data["Manufacturer"],
-                      "name" => device_data["Name"] || device_data["Id"],
-                      "description" => device_data["Description"],
-                      "id" => device_data["Id"],
-                      "slot_type" => device_data.dig("Oem", "Dell", "SlotType"),
-                      "bus_width" => device_data.dig("Oem", "Dell", "BusWidth"),
-                      "nic" => nil
-                    }
-                  end
-                end
-              end
-              
-              return pci_devices unless pci_devices.empty?
-            end
-          rescue JSON::ParserError
-            # Continue to next approach
-          end
-        end
-        
-        # Try NetworkAdapters as an alternative for finding PCIe devices (especially NICs and FC adapters)
-        nic_response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/NetworkAdapters?$expand=*($levels=1)")
-        
-        if nic_response.status == 200
-          begin
-            nic_data = JSON.parse(nic_response.body)
-            
-            pci_devices = []
-            
-            # Extract PCI info from network adapters
-            if nic_data["Members"] && !nic_data["Members"].empty?
-              nic_data["Members"].each do |adapter|
-                next unless adapter["Model"] || adapter["Manufacturer"]
-                
-                # Check if this is a Fiber Channel adapter by name or model
-                is_fc = (adapter["Name"] =~ /FC/i || adapter["Model"] =~ /FC/i || 
-                         adapter["Id"] =~ /FC/i || adapter["Description"] =~ /Fibre/i) ? true : false
-                
-                device_class = is_fc ? "FibreChannelController" : "NetworkController"
-                
-                pci_devices << {
-                  "device_class" => device_class,
-                  "manufacturer" => adapter["Manufacturer"],
-                  "name" => adapter["Name"] || adapter["Id"],
-                  "description" => adapter["Description"],
-                  "id" => adapter["Id"],
-                  "slot_type" => adapter.dig("Oem", "Dell", "SlotType") || 
-                                 (adapter["Id"] =~ /Slot\.(\d+)/ ? "Slot #{$1}" : nil),
-                  "bus_width" => nil,
-                  "nic" => adapter["@odata.id"]
-                }
-              end
-              
-              return pci_devices unless pci_devices.empty?
-            end
-          rescue JSON::ParserError
-            # Continue to fallback
-          end
-        end
-        
-        # Last resort: check if PCIeFunctions are directly available
-        pcie_functions_response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/PCIeFunctions?$expand=*($levels=1)")
-        
-        if pcie_functions_response.status == 200
-          begin
-            functions_data = JSON.parse(pcie_functions_response.body)
-            
-            if functions_data["Members"] && !functions_data["Members"].empty?
-              pci_devices = functions_data["Members"].map do |function|
-                {
-                  "device_class" => function["DeviceClass"] || "Unknown",
-                  "manufacturer" => function["Manufacturer"] || "Unknown",
-                  "name" => function["Name"] || function["Id"],
-                  "description" => function["Description"],
-                  "id" => function["Id"],
-                  "slot_type" => function.dig("Oem", "Dell", "SlotType"),
-                  "bus_width" => function.dig("Oem", "Dell", "DataBusWidth"),
-                  "nic" => nil
-                }
-              end
-              
-              return pci_devices
-            end
-          rescue JSON::ParserError
-            # Continue to fallback
-          end
-        end
-        
-        # Fallback for any version when all endpoints unavailable
-        puts "PCI device information not available through standard or alternative endpoints" if @verbose
-        return []
+      # iDRAC 9+: standard PCIeDevices endpoint with expand
+      if (data = safe_get("/redfish/v1/Chassis/System.Embedded.1/PCIeDevices?$expand=*($levels=1)"))
+        return data["Members"].map { |stub|
+          fn = stub.dig("Links", "PCIeFunctions", 0, "@odata.id")
+          pcie_fn = fn ? safe_get(fn) : nil
+          {
+            "device_class" => pcie_fn&.dig("DeviceClass"),
+            "manufacturer" => stub["Manufacturer"],
+            "name" => stub["Name"],
+            "description" => stub["Description"],
+            "id" => pcie_fn&.dig("Id") || stub["Id"],
+            "slot_type" => pcie_fn&.dig("Oem", "Dell", "DellPCIeFunction", "SlotType"),
+            "bus_width" => pcie_fn&.dig("Oem", "Dell", "DellPCIeFunction", "DataBusWidth"),
+            "nic" => pcie_fn&.dig("Links", "EthernetInterfaces", 0, "@odata.id")
+          }
+        }
+      end
+
+      # iDRAC 8: PCIeDevices via System endpoint
+      if (data = safe_get("/redfish/v1/Systems/System.Embedded.1?$select=PCIeDevices"))
+        devices = Array(data["PCIeDevices"]).filter_map { |link|
+          next unless link.is_a?(Hash) && link["@odata.id"]
+          d = safe_get(link["@odata.id"])
+          next unless d
+          {
+            "device_class" => d["DeviceType"] || "Unknown",
+            "manufacturer" => d["Manufacturer"],
+            "name" => d["Name"] || d["Id"],
+            "description" => d["Description"],
+            "id" => d["Id"],
+            "slot_type" => d.dig("Oem", "Dell", "SlotType"),
+            "bus_width" => d.dig("Oem", "Dell", "BusWidth"),
+            "nic" => nil
+          }
+        }
+        return devices unless devices.empty?
       end
+
+      # Fallback: NetworkAdapters
+      if (data = safe_get("/redfish/v1/Systems/System.Embedded.1/NetworkAdapters?$expand=*($levels=1)"))
+        devices = Array(data["Members"]).filter_map { |a|
+          next unless a["Model"] || a["Manufacturer"]
+          is_fc = [a["Name"], a["Model"], a["Id"], a["Description"]].any? { |f| f =~ /FC|Fibre/i }
+          {
+            "device_class" => is_fc ? "FibreChannelController" : "NetworkController",
+            "manufacturer" => a["Manufacturer"],
+            "name" => a["Name"] || a["Id"],
+            "description" => a["Description"],
+            "id" => a["Id"],
+            "slot_type" => a.dig("Oem", "Dell", "SlotType") || (a["Id"] =~ /Slot\.(\d+)/ ? "Slot #{$1}" : nil),
+            "bus_width" => nil,
+            "nic" => a["@odata.id"]
+          }
+        }
+        return devices unless devices.empty?
+      end
+
+      # Last resort: PCIeFunctions directly
+      if (data = safe_get("/redfish/v1/Systems/System.Embedded.1/PCIeFunctions?$expand=*($levels=1)"))
+        return Array(data["Members"]).map { |fn|
+          {
+            "device_class" => fn["DeviceClass"] || "Unknown",
+            "manufacturer" => fn["Manufacturer"] || "Unknown",
+            "name" => fn["Name"] || fn["Id"],
+            "description" => fn["Description"],
+            "id" => fn["Id"],
+            "slot_type" => fn.dig("Oem", "Dell", "SlotType"),
+            "bus_width" => fn.dig("Oem", "Dell", "DataBusWidth"),
+            "nic" => nil
+          }
+        }
+      end
+
+      []
     end
 
     # Map NICs to PCI bus IDs for Mellanox cards

data/lib/idrac/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.7
 platform: ruby
 authors:
 - Jonathan Siegel