idrac 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e29d49fd29e12b9b169c281408e19002beb792c6ad957595190547b8d40ea04
-  data.tar.gz: 0b52402b5396fd59801c2be34ce764d2e27e90049d6f14dbf501bbb02308339a
+  metadata.gz: 68c60caff773a2fd54e340a7ec1abbe02b8f9529d9f44527984923d22515ca9c
+  data.tar.gz: 62bf014eb0927473304cb2a4da06d09d1ca2aee67be4f4a6849d9295ef252347
 SHA512:
-  metadata.gz: 1aba6ce8154a8a3d91eebf28a65ce2c7522207e37fd3777ad5b34dd7e8f61d198d9fa726cdd6f4f1b5d7176c4d2b9a6a274451df01c09a177e7024c7c6102f7f
-  data.tar.gz: 502b02ee0ab18757af3dfe345011ef0311b2432c8d1c7895a6a774fdf8dd099ae2cadbde4c89f7b5939f36505ce9a6fcab7540586472d03e719224be97cffce9
+  metadata.gz: 9bd33453fc8fcd7603e4ee4c34a1e63dce9da32eca413b9db297b590dae5e8787e6e46e72634dfbb0ae19cfb2b9b1fbb06702f67ff5a783ed388d8c0056bb583
+  data.tar.gz: b1f30af2c4ff18ae490d0a66a9fd58d6e1da2407935b0d999c2ca635fd3a7f5d184c541f6b9eee38bd6080b1db5cb4cc5feabf83e983384d63519f7973672617

data/bin/idrac

@@ -918,6 +918,27 @@ module IDRAC
       end
     end
 
+    desc "system_pci_devices", "Get PCI device information"
+    map "system:pci-devices" => :system_pci_devices
+    map "system:pci:devices" => :system_pci_devices
+    def system_pci_devices
+      with_idrac_client do |client|
+        pci_devices = client.pci_devices
+        
+        puts "\nPCI Devices (#{pci_devices.size}):".green.bold
+        pci_devices.each do |device|
+          puts "#{device["name"]}:".bold
+          puts "  Manufacturer: #{device["manufacturer"]}".cyan if device["manufacturer"]
+          puts "  Device Class: #{device["device_class"]}".cyan if device["device_class"]
+          puts "  Description: #{device["description"]}".cyan if device["description"]
+          puts "  ID: #{device["id"]}".cyan if device["id"]
+          puts "  Slot Type: #{device["slot_type"]}".cyan if device["slot_type"]
+          puts "  Bus Width: #{device["bus_width"]}".cyan if device["bus_width"]
+          puts ""
+        end
+      end
+    end
+
     desc "system_idrac_network", "Get iDRAC network configuration"
     map "system:idrac_network" => :system_idrac_network
     def system_idrac_network
@@ -1085,16 +1106,16 @@ module IDRAC
       with_idrac_client do |client|
         info = client.system_info
         
-        if info.is_dell
+        if info["is_dell"]
           puts "Dell iDRAC System:".green.bold
-          puts "  Service Tag: #{info.service_tag}".cyan
-          puts "  Model: #{info.model}".cyan
-          puts "  iDRAC Version: #{info.idrac_version}".cyan
-          puts "  Firmware Version: #{info.firmware_version}".cyan
+          puts "  Service Tag: #{info["service_tag"]}".cyan
+          puts "  Model: #{info["model"]}".cyan
+          puts "  iDRAC Version: #{info["idrac_version"]}".cyan
+          puts "  Firmware Version: #{info["firmware_version"]}".cyan
         else
           puts "Not a Dell iDRAC system".yellow
-          puts "  Product: #{info.product}".cyan
-          if info.is_ancient_dell
+          puts "  Product: #{info["product"]}".cyan
+          if info["is_ancient_dell"]
             puts "  Ancient Dell System detected. Update firmware.".yellow
           end
         end

data/lib/idrac/client.rb

@@ -22,6 +22,7 @@ module IDRAC
     include VirtualMedia
     include Boot
     include License
+    include SystemConfig
 
     def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: false, direct_mode: false, auto_delete_sessions: true, retry_count: 3, retry_delay: 1)
       @host = host

data/lib/idrac/system.rb

@@ -235,6 +235,7 @@ 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
@@ -257,17 +258,17 @@ module IDRAC
             
             # 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
+              "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]}"
+            puts "PCI Device: #{device_info["name"]} > #{device_info["manufacturer"]} > #{device_info["device_class"]} > #{device_info["description"]} > #{device_info["id"]}"
             
             device_info
           end
@@ -277,7 +278,117 @@ module IDRAC
           raise Error, "Failed to parse PCI devices response: #{response.body}"
         end
       else
-        raise Error, "Failed to get PCI devices. Status code: #{response.status}"
+        # 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 []
       end
     end
 

data/lib/idrac/system_config.rb

@@ -0,0 +1,369 @@
+require 'json'
+require 'colorize'
+
+module IDRAC
+  module SystemConfig
+    # Get the system configuration profile for a given target (e.g. "RAID")
+    def get_system_configuration_profile(target: "RAID")
+      tries = 0
+      location = nil
+      started_at = Time.now
+      
+      while location.nil?
+        debug "Exporting System Configuration try #{tries+=1}..."
+        
+        response = authenticated_request(:post, 
+          "/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ExportSystemConfiguration", 
+          body: {"ExportFormat": "JSON", "ShareParameters":{"Target": target}}.to_json,
+          headers: {"Content-Type" => "application/json"}
+        )
+
+        if response.status == 400
+          debug "Failed exporting system configuration: #{response.body}", 1, :red
+          raise Error, "Failed exporting system configuration profile"
+        elsif response.status.between?(401, 599)
+          debug "Failed exporting system configuration: #{response.body}", 1, :red
+          
+          # Parse error response
+          error_data = JSON.parse(response.body) rescue nil
+          
+          if error_data && error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+            message_info = error_data["error"]["@Message.ExtendedInfo"]
+            
+            # Check for specific error conditions
+            if message_info.any? { |m| m["Message"] =~ /existing configuration job is already in progress/ }
+              debug "Existing configuration job is already in progress, retrying...", 1, :yellow
+              sleep 30
+            elsif message_info.any? { |m| m["Message"] =~ /job operation is already running/ }
+              debug "Existing job operation is already in progress, retrying...", 1, :yellow
+              sleep 60
+            else
+              # Detailed error info for debugging
+              debug "*" * 80, 1, :red
+              debug "Headers: #{response.headers.inspect}", 1, :red
+              debug "Body: #{response.body}", 1, :yellow
+              
+              # Extract the first error message if available
+              error_message = message_info.first["Message"] rescue "Unknown error"
+              debug "Error: #{error_message}", 1, :red
+              
+              raise Error, "Failed to export SCP: #{error_message}"
+            end
+          else
+            raise Error, "Failed to export SCP with status #{response.status}"
+          end
+        else
+          # Success path - extract location header
+          location = response.headers["location"]
+          
+          if location.nil? || location.empty?
+            raise Error, "Empty location header in response: #{response.headers.inspect}"
+          end
+        end
+
+        # Progress reporting
+        minutes_elapsed = ((Time.now - started_at).to_f / 60).to_i
+        debug "Waiting for export to complete... #{minutes_elapsed} minutes", 1, :yellow
+        
+        # Exponential backoff
+        sleep 2**[tries, 6].min # Cap at 64 seconds
+        
+        if tries > 10
+          raise Error, "Failed exporting SCP after #{tries} tries, location: #{location}"
+        end
+      end
+
+      # Extract job ID from location
+      job_id = location.split("/").last
+      
+      # Poll for job completion
+      job_complete = false
+      scp = nil
+      
+      while !job_complete
+        job_response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks/#{job_id}")
+        
+        if job_response.status == 200
+          job_data = JSON.parse(job_response.body)
+          
+          if ["Running", "Pending", "New"].include?(job_data["TaskState"])
+            debug "Job status: #{job_data["TaskState"]}, waiting...", 2
+            sleep 3
+          else
+            job_complete = true
+            scp = job_data
+            
+            # Verify we have the system configuration data
+            unless scp["SystemConfiguration"]
+              raise Error, "Failed exporting SCP, taskstate: #{scp["TaskState"]}, taskstatus: #{scp["TaskStatus"]}"
+            end
+          end
+        else
+          raise Error, "Failed to check job status: #{job_response.status} - #{job_response.body}"
+        end
+      end
+      
+      return scp
+    end
+
+    # Set an attribute in a system configuration profile
+    def set_scp_attribute(scp, name, value)
+      # Make a deep copy to avoid modifying the original
+      scp_copy = JSON.parse(scp.to_json)
+      
+      # Clear unrelated attributes for quicker transfer
+      scp_copy["SystemConfiguration"].delete("Comments")
+      scp_copy["SystemConfiguration"].delete("TimeStamp")
+      scp_copy["SystemConfiguration"].delete("ServiceTag")
+      scp_copy["SystemConfiguration"].delete("Model")
+
+      # Skip these attribute groups to make the transfer faster
+      excluded_prefixes = [
+        "User", "Telemetry", "SecurityCertificate", "AutoUpdate", "PCIe", "LDAP", "ADGroup", "ActiveDirectory",
+        "IPMILan", "EmailAlert", "SNMP", "IPBlocking", "IPMI", "Security", "RFS", "OS-BMC", "SupportAssist",
+        "Redfish", "RedfishEventing", "Autodiscovery", "SEKM-LKC", "Telco-EdgeServer", "8021XSecurity", "SPDM",
+        "InventoryHash", "RSASecurID2FA", "USB", "NIC", "IPv6", "NTP", "Logging", "IOIDOpt", "SSHCrypto",
+        "RemoteHosts", "SysLog", "Time", "SmartCard", "ACME", "ServiceModule", "Lockdown",
+        "DefaultCredentialMitigation", "AutoOSLockGroup", "LocalSecurity", "IntegratedDatacenter",
+        "SecureDefaultPassword.1#ForceChangePassword", "SwitchConnectionView.1#Enable", "GroupManager.1",
+        "ASRConfig.1#Enable", "SerialCapture.1#Enable", "CertificateManagement.1",
+        "Update", "SSH", "SysInfo", "GUI"
+      ]
+      
+      # Remove excluded attribute groups
+      if scp_copy["SystemConfiguration"]["Components"] && 
+         scp_copy["SystemConfiguration"]["Components"][0] && 
+         scp_copy["SystemConfiguration"]["Components"][0]["Attributes"]
+        
+        attrs = scp_copy["SystemConfiguration"]["Components"][0]["Attributes"]
+        
+        attrs.reject! do |attr|
+          excluded_prefixes.any? { |prefix| attr["Name"] =~ /\A#{prefix}/ }
+        end
+        
+        # Update or add the specified attribute
+        if attrs.find { |a| a["Name"] == name }.nil?
+          # Attribute doesn't exist, create it
+          attrs << { "Name" => name, "Value" => value, "Set On Import" => "True" }
+        else
+          # Update existing attribute
+          attrs.find { |a| a["Name"] == name }["Value"] = value
+          attrs.find { |a| a["Name"] == name }["Set On Import"] = "True"
+        end
+        
+        scp_copy["SystemConfiguration"]["Components"][0]["Attributes"] = attrs
+      end
+      
+      return scp_copy
+    end
+
+    # Helper method to normalize enabled/disabled values
+    def normalize_enabled_value(v)
+      return "Disabled" if v.nil? || v == false
+      return "Enabled"  if v == true
+      
+      raise Error, "Invalid value for normalize_enabled_value: #{v}" unless v.is_a?(String)
+      
+      if v.strip.downcase == "enabled"
+        return "Enabled"
+      else
+        return "Disabled"
+      end
+    end
+
+    # Apply a system configuration profile to the iDRAC
+    def set_system_configuration_profile(scp, target: "ALL", reboot: false, retry_count: 0)
+      # Ensure scp has the proper structure with SystemConfiguration wrapper
+      scp_to_apply = if scp.is_a?(Hash) && scp["SystemConfiguration"]
+        scp
+      else
+        # Ensure scp is an array of components
+        components = scp.is_a?(Array) ? scp : [scp]
+        { "SystemConfiguration" => { "Components" => components } }
+      end
+
+      # Create the import parameters
+      params = { 
+        "ImportBuffer" => JSON.pretty_generate(scp_to_apply),
+        "ShareParameters" => {"Target" => target},
+        "ShutdownType" => "Forced",
+        "HostPowerState" => reboot ? "On" : "Off"
+      }
+      
+      debug "Importing System Configuration...", 1, :blue
+      debug "Configuration: #{JSON.pretty_generate(scp_to_apply)}", 3
+      
+      # Make the API request
+      response = authenticated_request(
+        :post, 
+        "/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ImportSystemConfiguration",
+        body: params.to_json,
+        headers: {"Content-Type" => "application/json"}
+      )
+      
+      # Check for immediate errors
+      if response.headers["content-length"].to_i > 0
+        debug response.inspect, 1, :red
+        return { status: :failed, error: "Failed importing SCP: #{response.body}" }
+      end
+      
+      # Get the job location
+      job_location = response.headers["location"]
+      if job_location.nil? || job_location.empty?
+        debug response.inspect, 1, :blue
+        return { status: :failed, error: "Failed importing SCP... invalid iDRAC response" }
+      end
+      
+      # Extract job ID and monitor the task
+      job_id = job_location.split("/").last
+      task = nil
+      
+      begin
+        loop do
+          task_response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks/#{job_id}")
+          
+          if task_response.status == 200
+            task = JSON.parse(task_response.body)
+            
+            if task["TaskState"] != "Running"
+              break
+            end
+            
+            debug "Waiting for task to complete...: #{task["TaskState"]} #{task["TaskStatus"]}", 1
+            sleep 5
+          else
+            return { 
+              status: :failed, 
+              error: "Failed to check task status: #{task_response.status} - #{task_response.body}" 
+            }
+          end
+        end
+        
+        # Check final task state
+        if task["TaskState"] == "Completed" && task["TaskStatus"] == "OK"
+          return { status: :success }
+        else
+          # For debugging purposes
+          debug task.inspect, 1, :yellow
+          
+          # Extract any messages from the response
+          messages = []
+          if task["Messages"] && task["Messages"].is_a?(Array)
+            messages = task["Messages"].map { |m| m["Message"] }.compact
+          end
+          
+          return { 
+            status: :failed, 
+            task_state: task["TaskState"], 
+            task_status: task["TaskStatus"],
+            messages: messages,
+            error: messages.first || "Task failed with state: #{task["TaskState"]}"
+          }
+        end
+      rescue => e
+        return { status: :error, error: "Exception monitoring task: #{e.message}" }
+      end
+    end
+
+    # Helper method to create an SCP component with the specified FQDD and attributes
+    def make_scp(fqdd:, components: [], attributes: {})
+      com = []
+      att = []
+      
+      # Process components
+      components.each do |component|
+        com << component
+      end
+      
+      # Process attributes
+      attributes.each do |k, v|
+        if v.is_a?(Array)
+          v.each do |value|
+            att << { "Name" => k, "Value" => value, "Set On Import" => "True" }
+          end
+        elsif v.is_a?(Integer)
+          # Convert integers to strings
+          att << { "Name" => k, "Value" => v.to_s, "Set On Import" => "True" }
+        elsif v.is_a?(Hash)
+          # Handle nested components
+          v.each do |kk, vv|
+            com += make_scp(fqdd: kk, attributes: vv)
+          end
+        else
+          att << { "Name" => k, "Value" => v, "Set On Import" => "True" }
+        end
+      end
+      
+      # Build the final component
+      bundle = { "FQDD" => fqdd }
+      bundle["Components"] = com if com.any?
+      bundle["Attributes"] = att if att.any?
+      
+      return bundle
+    end
+
+    # Convert an SCP array to a hash for easier manipulation
+    def scp_to_hash(scp)
+      scp.inject({}) do |acc, component|
+        acc[component["FQDD"]] = component["Attributes"]
+        acc
+      end
+    end
+
+    # Convert an SCP hash back to array format
+    def hash_to_scp(hash)
+      hash.inject([]) do |acc, (fqdd, attributes)|
+        acc << { "FQDD" => fqdd, "Attributes" => attributes }
+        acc
+      end
+    end
+
+    # Merge two SCPs together
+    def merge_scp(scp1, scp2)
+      return scp1 || scp2 unless scp1 && scp2 # Return the one that's not nil if either is nil
+      
+      # Make them both arrays in case they aren't
+      scp1_array = scp1.is_a?(Array) ? scp1 : [scp1]
+      scp2_array = scp2.is_a?(Array) ? scp2 : [scp2]
+      
+      # Convert to hashes for merging
+      hash1 = scp_to_hash(scp1_array)
+      hash2 = scp_to_hash(scp2_array)
+      
+      # Perform deep merge
+      merged = deep_merge(hash1, hash2)
+      
+      # Convert back to SCP array format
+      hash_to_scp(merged)
+    end
+
+    private
+
+    # Helper method for deep merging of hashes
+    def deep_merge(hash1, hash2)
+      result = hash1.dup
+      
+      hash2.each do |key, value|
+        if result[key].is_a?(Array) && value.is_a?(Array)
+          # For arrays of attributes, merge by name
+          existing_names = result[key].map { |attr| attr["Name"] }
+          
+          value.each do |attr|
+            if existing_index = existing_names.index(attr["Name"])
+              # Update existing attribute
+              result[key][existing_index] = attr
+            else
+              # Add new attribute
+              result[key] << attr
+            end
+          end
+        else
+          # For other values, just replace
+          result[key] = value
+        end
+      end
+      
+      result
+    end
+  end
+end 

data/lib/idrac/version.rb

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

data/lib/idrac.rb

@@ -53,3 +53,4 @@ require 'idrac/virtual_media'
 require 'idrac/boot'
 require 'idrac/license'
 require 'idrac/client'
+require 'idrac/system_config'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Jonathan Siegel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-24 00:00:00.000000000 Z
+date: 2025-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -276,6 +276,7 @@ files:
 - lib/idrac/session.rb
 - lib/idrac/storage.rb
 - lib/idrac/system.rb
+- lib/idrac/system_config.rb
 - lib/idrac/version.rb
 - lib/idrac/virtual_media.rb
 - lib/idrac/web.rb