idrac 0.9.4 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54237d0e5e104838b8770088791b1896b11928d0092572035ee05117de1d6733
-  data.tar.gz: 802a048dcf46d8d9a1eab4626be4425269ee58d0012b61f1ac167b44a8b1def9
+  metadata.gz: cc0edda7bbcbf4e86782d914c909557f3bf6f24e5fa40284761f0e8d550c18b5
+  data.tar.gz: c8e3b1fa48d0eba346ab6d3410894e7ecce6c211c5f8719653c99bb384222e9e
 SHA512:
-  metadata.gz: 95ff7c2f6e83194632b4ceb9febd251f01332f39271c02bfc2e0f35e677159b873b7ff74a8906f5b293af855aa2fb3f69ed4e73242be8ca704f6346da507c9a8
-  data.tar.gz: 94f8e2b5ab66ff0cf428bdb1903d3ba3d38d9b3e2002323e36a866ffb4461ae22a2766861550d4daf0fe74b274e2991ef9280fd9732581af9d0b86d3209b7047
+  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

@@ -26,15 +26,6 @@ module IDRAC
 
     private
 
-    # GET that returns parsed JSON on 200, nil otherwise. Never raises on 4xx.
-    def safe_get(path)
-      response = authenticated_request(:get, path) { |r| r }
-      return nil unless response.status == 200
-      JSON.parse(response.body)
-    rescue JSON::ParserError
-      nil
-    end
-
     def compute_license_version
       license = license_info
       if license

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.4"
+  VERSION = "0.9.7"
 end

metadata

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