idrac 0.5.10 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1097b98fc3b31d5e19268ca31db441d03d791fdcca96a6d85418badad0db534f
-  data.tar.gz: 6132fef1177ce26aef2045c3cecf1c81625ba09f0beaa6387126b0b1cb850d3f
+  metadata.gz: 5c77b78a7bad9201ed36f9570e2d0d39dc57559964d736648fdcd3f34e46fded
+  data.tar.gz: 0e5656537537fac5cbc02cc72c5c23e174c30d76c90d3cc80b2dd4da36d20ec4
 SHA512:
-  metadata.gz: 67974993e8fe893654a3549b500f018bed2796b476c78cca99894ec003584b72eeb14b7dd6dfd7c0029f47acf17d7b454eed7cf5fd850dcf1a36ddc57c474a96
-  data.tar.gz: 6cbfe56bce022b0cd2ae1cc2c74a6fc644422b323edefd913b819b1dd49f702cb7134ffbd8e03cf4d2b489d587548b46623f1188e6daaec2b3acbe95ebbff415
+  metadata.gz: f89101dedb96aeabd91eb5c210231d94500f65e41bd85c497a76c23478f658170d30ab11ba1ece65d113ae66a8736dd15ad6d4d44ecddf8e8da2ae3f6cd570d7
+  data.tar.gz: 7a072578dd6b178bc59c0ac09a66cd5752d1dd62d530d65c964aa624cf209df5bb1ed5189045ca04e3b4cab880d26646d3b045364aa352cde5fae3cca97dc6ff

data/README.md

@@ -171,23 +171,26 @@ client.clear_lifecycle!
 # Clear System Event Logs
 client.clear_system_event_logs!
 
-# Working with RecursiveOpenStruct objects
-# Many methods return data as RecursiveOpenStruct objects for easier property access
+# Working with hash objects
+# Methods return data as Ruby hashes with string keys for consistent access
+
+# Working with system components
+# Methods return data as Ruby hashes with string keys for consistent access
 
 # Get memory information
 memory_modules = client.memory
 memory_modules.each do |dimm|
-  # Access properties directly as methods
-  puts "#{dimm.name}: #{dimm.capacity_bytes / (1024**3)}GB, Speed: #{dimm.speed_mhz}MHz"
+  # Access properties via string keys
+  puts "#{dimm["name"]}: #{dimm["capacity_bytes"] / (1024**3)}GB, Speed: #{dimm["speed_mhz"]}MHz"
 end
 
 # Get storage information
 controller = client.controller
 volumes = client.volumes(controller)
 volumes.each do |volume|
-  # Access properties via dot notation
-  puts "#{volume.name} (#{volume.raid_level}): #{volume.capacity_bytes / (1024**3)}GB"
-  puts "  Health: #{volume.health}, FastPath: #{volume.fastpath}"
+  # Access properties via string keys
+  puts "#{volume["name"]} (#{volume["raid_level"]}): #{volume["capacity_bytes"] / (1024**3)}GB"
+  puts "  Health: #{volume["health"]}, FastPath: #{volume["fastpath"]}"
 end
 
 # Create a client with auto_delete_sessions disabled

data/bin/idrac

@@ -581,17 +581,17 @@ module IDRAC
         puts "-" * 80
         
         controllers.each do |controller|
-          puts "Controller: #{controller[:name]}".cyan.bold
-          puts "  Model:           #{controller[:model]}"
-          puts "  Status:          #{controller[:status]}"
-          puts "  Drives:          #{controller[:drives_count]}"
-          puts "  Firmware:        #{controller[:firmware_version]}"
-          puts "  Type:            #{controller[:controller_type]}"
-          puts "  PCI Slot:        #{controller[:pci_slot]}"
+          puts "Controller: #{controller.name}".cyan.bold
+          puts "  Model:           #{controller.model}"
+          puts "  Status:          #{controller.status}"
+          puts "  Drives:          #{controller.drives_count}"
+          puts "  Firmware:        #{controller.firmware_version}"
+          puts "  Type:            #{controller.controller_type}"
+          puts "  PCI Slot:        #{controller.pci_slot}"
           
-          if controller[:encryption_capability]
-            puts "  Encryption:      #{controller[:encryption_capability]}"
-            puts "  Encryption Mode: #{controller[:encryption_mode] || 'Disabled'}"
+          if controller.encryption_capability
+            puts "  Encryption:      #{controller.encryption_capability}"
+            puts "  Encryption Mode: #{controller.encryption_mode || 'Disabled'}"
           end
           
           puts
@@ -675,7 +675,7 @@ module IDRAC
         confirmation = $stdin.gets.chomp.downcase
         
         if confirmation == 'y'
-          client.create_virtual_disk(controller.odata_Id, drives, name: options[:name], raid_type: options[:raid])
+          client.create_virtual_disk(controller.odata_id, drives, name: options[:name], raid_type: options[:raid])
           puts "Volume created successfully".green
         else
           puts "Operation cancelled".yellow

data/idrac.gemspec

@@ -41,7 +41,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "thor", "~> 1.2", ">= 1.2.0"
   spec.add_dependency "base64", "~> 0.1", ">= 0.1.0"
   spec.add_dependency "colorize", "~> 1.1", ">= 1.1.0"
-  spec.add_dependency "recursive-open-struct", "~> 1.1", ">= 1.1.0"
   spec.add_dependency "activesupport", "~> 6.0"
 
   # Development dependencies

data/lib/idrac/jobs.rb

@@ -3,21 +3,16 @@ require 'colorize'
 
 module IDRAC
   module Jobs
-    # Get a list of jobs
+    # Summarize jobs
     def jobs
       response = authenticated_request(:get, '/redfish/v1/Managers/iDRAC.Embedded.1/Jobs?$expand=*($levels=1)')
       
       if response.status == 200
         begin
           jobs_data = JSON.parse(response.body)
-          puts "Jobs: #{jobs_data['Members'].count}"
-          if jobs_data['Members'].count > 0
-            puts "Job IDs:"
-            jobs_data["Members"].each do |job|
-              puts "  #{job['Id']}"
-            end
-          end
-          return jobs_data
+          { completed_count:  jobs_data["Members"].select { |j| j["JobState"] == "Completed" }.count,    
+            incomplete_count: jobs_data["Members"].select { |j| j["JobState"] != "Completed" }.count,
+            total_count:      jobs_data["Members"].count }
         rescue JSON::ParserError
           raise Error, "Failed to parse jobs response: #{response.body}"
         end

data/lib/idrac/license.rb

@@ -1,7 +1,7 @@
 module IDRAC
   module License
     # Gets the license information from the iDRAC
-    # @return [RecursiveOpenStruct] License details
+    # @return [Hash] License details
     def license_info
       response = authenticated_request(:get, "/redfish/v1/LicenseService/Licenses")
       if response.status != 200
@@ -32,7 +32,7 @@ module IDRAC
       license_details = JSON.parse(license_response.body)
       debug "License details: #{license_details}", 2
 
-      return RecursiveOpenStruct.new(license_details, recurse_over_arrays: true)
+      return license_details
     end
 
     # Extracts the iDRAC version from the license description
@@ -43,15 +43,15 @@ module IDRAC
 
       # Check the Description field, which often contains the version
       # Example: "iDRAC9 Enterprise License"
-      if license.Description && license.Description.match(/iDRAC(\d+)/i)
-        version = license.Description.match(/iDRAC(\d+)/i)[1].to_i
+      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 && license.Name.match(/iDRAC(\d+)/i)
-        version = license.Name.match(/iDRAC(\d+)/i)[1].to_i
+      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

data/lib/idrac/lifecycle.rb

@@ -148,14 +148,21 @@ module IDRAC
     
     # Get the system event logs
     def get_system_event_logs
-      path = 'Managers/iDRAC.Embedded.1/Logs/Sel?$expand=*($levels=1)'
+      path = '/redfish/v1/Managers/iDRAC.Embedded.1/Logs/Sel?$expand=*($levels=1)'
       
       response = authenticated_request(:get, path)
       
       if response.status == 200
         begin
-          logs_data = JSON.parse(response.body)
-          return logs_data
+          data = JSON.parse(response.body)['Members'].map do |entry|
+              { 
+                id: entry['Id'],
+                created: entry['Created'],
+                message: entry['Message'],
+                severity: entry['Severity']
+              }
+            end
+          return data # RecursiveOpenStruct.new(data, recurse_over_arrays: true)
         rescue JSON::ParserError
           raise Error, "Failed to parse system event logs response: #{response.body}"
         end
@@ -166,7 +173,7 @@ module IDRAC
     
     # Clear the system event logs
     def clear_system_event_logs!
-      path = 'Managers/iDRAC.Embedded.1/LogServices/Sel/Actions/LogService.ClearLog'
+      path = '/redfish/v1/Managers/iDRAC.Embedded.1/LogServices/Sel/Actions/LogService.ClearLog'
       
       response = authenticated_request(:post, path, body: {}.to_json, headers: { 'Content-Type' => 'application/json' })
       

data/lib/idrac/storage.rb

@@ -1,6 +1,5 @@
 require 'json'
 require 'colorize'
-require 'recursive-open-struct'
 
 module IDRAC
   module Storage
@@ -10,24 +9,24 @@ module IDRAC
       controller_list = controllers
       
       puts "Controllers".green
-      controller_list.each { |c| puts "#{c.name} > #{c.drives_count}" }
+      controller_list.each { |c| puts "#{c["name"]} > #{c["drives_count"]}" }
       
       puts "Drives".green
       controller_list.each do |c|
-        puts "Storage: #{c.name} > #{c.status} > #{c.drives_count}"
+        puts "Storage: #{c["name"]} > #{c["status"]} > #{c["drives_count"]}"
       end
       
       # Find the controller with the most drives (usually the PERC)
-      controller_info = controller_list.max_by { |c| c.drives_count }
+      controller_info = controller_list.max_by { |c| c["drives_count"] }
       
-      if controller_info.name =~ /PERC/
-        puts "Found #{controller_info.name}".green
+      if controller_info["name"] =~ /PERC/
+        puts "Found #{controller_info["name"]}".green
       else
-        puts "Found #{controller_info.name} but continuing...".yellow
+        puts "Found #{controller_info["name"]} but continuing...".yellow
       end
       
       # Return the raw controller data
-      controller_info.raw
+      controller_info["raw"]
     end
 
     # Get all storage controllers and return them as an array
@@ -38,26 +37,25 @@ module IDRAC
         begin
           data = JSON.parse(response.body)
           
-          # Transform and return all controllers as an array of RecursiveOpenStruct objects with consistent keys
+          # Transform and return all controllers as an array of hashes with string keys
           controllers = data["Members"].map do |controller|
-            controller_data = {
-              name: controller["Name"],
-              model: controller["Model"],
-              drives_count: controller["Drives"].size,
-              status: controller["Status"]["Health"] || "N/A",
-              firmware_version: controller.dig("StorageControllers", 0, "FirmwareVersion"),
-              encryption_mode: controller.dig("Oem", "Dell", "DellController", "EncryptionMode"),
-              encryption_capability: controller.dig("Oem", "Dell", "DellController", "EncryptionCapability"),
-              controller_type: controller.dig("Oem", "Dell", "DellController", "ControllerType"),
-              pci_slot: controller.dig("Oem", "Dell", "DellController", "PCISlot"),
-              raw: controller,
-              odata_id: controller["@odata.id"]
+            {
+              "name" => controller["Name"],
+              "model" => controller["Model"],
+              "drives_count" => controller["Drives"].size,
+              "status" => controller.dig("Status", "Health") || "N/A",
+              "firmware_version" => controller.dig("StorageControllers", 0, "FirmwareVersion"),
+              "encryption_mode" => controller.dig("Oem", "Dell", "DellController", "EncryptionMode"),
+              "encryption_capability" => controller.dig("Oem", "Dell", "DellController", "EncryptionCapability"),
+              "controller_type" => controller.dig("Oem", "Dell", "DellController", "ControllerType"),
+              "pci_slot" => controller.dig("Oem", "Dell", "DellController", "PCISlot"),
+              "raw" => controller,
+              "volumes_odata_id" => controller.dig("Volumes", "@odata.id"),
+              "@odata.id" => controller["@odata.id"]
             }
-            
-            RecursiveOpenStruct.new(controller_data, recurse_over_arrays: true)
           end
           
-          return controllers.sort_by { |c| c.name }
+          return controllers.sort_by { |c| c["name"] }
         rescue JSON::ParserError
           raise Error, "Failed to parse controllers response: #{response.body}"
         end
@@ -66,23 +64,12 @@ module IDRAC
       end
     end
 
-    # Check if controller supports encryption
-    def controller_encryption_capable?(controller)
-      return false unless controller
-      controller.dig("Oem", "Dell", "DellController", "EncryptionCapability") =~ /localkey/i
-    end
-
-    # Check if controller encryption is enabled
-    def controller_encryption_enabled?(controller)
-      return false unless controller
-      controller.dig("Oem", "Dell", "DellController", "EncryptionMode") =~ /localkey/i
-    end
-
     # Get information about physical drives
     def drives(controller)
       raise Error, "Controller not provided" unless controller
       
-      controller_path = controller["@odata.id"].split("v1/").last
+      odata_id_path = controller["@odata.id"] || controller["odata_id"]
+      controller_path = odata_id_path.split("v1/").last
       response = authenticated_request(:get, "/redfish/v1/#{controller_path}?$expand=*($levels=1)")
       
       if response.status == 200
@@ -91,29 +78,27 @@ module IDRAC
           drives = data["Drives"].map do |body|
             serial = body["SerialNumber"] 
             serial = body["Identifiers"].first["DurableName"] if serial.blank?
-            drive_data = { 
-              serial: serial,
-              model: body["Model"],
-              name: body["Name"],
-              capacity_bytes: body["CapacityBytes"],
-              health: body["Status"]["Health"] ? body["Status"]["Health"] : "N/A",
-              speed_gbp: body["CapableSpeedGbs"],
-              manufacturer: body["Manufacturer"],
-              media_type: body["MediaType"],
-              failure_predicted: body["FailurePredicted"],
-              life_left_percent: body["PredictedMediaLifeLeftPercent"],
-              certified: body.dig("Oem", "Dell", "DellPhysicalDisk", "Certified"),
-              raid_status: body.dig("Oem", "Dell", "DellPhysicalDisk", "RaidStatus"),
-              operation_name: body.dig("Oem", "Dell", "DellPhysicalDisk", "OperationName"),
-              operation_progress: body.dig("Oem", "Dell", "DellPhysicalDisk", "OperationPercentCompletePercent"),
-              encryption_ability: body["EncryptionAbility"],
-              "@odata.id": body["@odata.id"]
+            {
+              "serial" => serial,
+              "model" => body["Model"],
+              "name" => body["Name"],
+              "capacity_bytes" => body["CapacityBytes"],
+              "health" => body.dig("Status", "Health") || "N/A",
+              "speed_gbp" => body["CapableSpeedGbs"],
+              "manufacturer" => body["Manufacturer"],
+              "media_type" => body["MediaType"],
+              "failure_predicted" => body["FailurePredicted"],
+              "life_left_percent" => body["PredictedMediaLifeLeftPercent"],
+              "certified" => body.dig("Oem", "Dell", "DellPhysicalDisk", "Certified"),
+              "raid_status" => body.dig("Oem", "Dell", "DellPhysicalDisk", "RaidStatus"),
+              "operation_name" => body.dig("Oem", "Dell", "DellPhysicalDisk", "OperationName"),
+              "operation_progress" => body.dig("Oem", "Dell", "DellPhysicalDisk", "OperationPercentCompletePercent"),
+              "encryption_ability" => body["EncryptionAbility"],
+              "@odata.id" => body["@odata.id"]
             }
-            
-            RecursiveOpenStruct.new(drive_data, recurse_over_arrays: true)
           end
           
-          return drives.sort_by { |d| d.name }
+          return drives.sort_by { |d| d["name"] }
         rescue JSON::ParserError
           raise Error, "Failed to parse drives response: #{response.body}"
         end
@@ -128,9 +113,11 @@ module IDRAC
       
       puts "Volumes (e.g. Arrays)".green
       
-      v = controller["Volumes"]
-      path = v["@odata.id"].split("v1/").last
-      response = authenticated_request(:get, "/redfish/v1/#{path}?$expand=*($levels=1)")
+      odata_id_path = controller["volumes_odata_id"]
+      if odata_id_path.nil?
+        raise Error, "No volumes_odata_id found in controller data. Make sure the controller is properly initialized."
+      end
+      response = authenticated_request(:get, "#{odata_id_path}?$expand=*($levels=1)")
       
       if response.status == 200
         begin
@@ -138,42 +125,42 @@ module IDRAC
           volumes = data["Members"].map do |vol|
             drives = vol["Links"]["Drives"]
             volume_data = { 
-              name: vol["Name"], 
-              capacity_bytes: vol["CapacityBytes"], 
-              volume_type: vol["VolumeType"],
-              drives: drives,
-              write_cache_policy: vol.dig("Oem", "Dell", "DellVirtualDisk", "WriteCachePolicy"),
-              read_cache_policy: vol.dig("Oem", "Dell", "DellVirtualDisk", "ReadCachePolicy"),
-              stripe_size: vol.dig("Oem", "Dell", "DellVirtualDisk", "StripeSize"),
-              raid_level: vol["RAIDType"],
-              encrypted: vol["Encrypted"],
-              lock_status: vol.dig("Oem", "Dell", "DellVirtualDisk", "LockStatus"),
-              odata_id: vol["@odata.id"]
+              "name" => vol["Name"], 
+              "capacity_bytes" => vol["CapacityBytes"], 
+              "volume_type" => vol["VolumeType"],
+              "drives" => drives,
+              "write_cache_policy" => vol.dig("Oem", "Dell", "DellVirtualDisk", "WriteCachePolicy"),
+              "read_cache_policy" => vol.dig("Oem", "Dell", "DellVirtualDisk", "ReadCachePolicy"),
+              "stripe_size" => vol.dig("Oem", "Dell", "DellVirtualDisk", "StripeSize"),
+              "raid_level" => vol["RAIDType"],
+              "encrypted" => vol["Encrypted"],
+              "lock_status" => vol.dig("Oem", "Dell", "DellVirtualDisk", "LockStatus"),
+              "@odata.id" => vol["@odata.id"]
             }
             
             # Check FastPath settings
-            volume_data[:fastpath] = fastpath_good?(vol)
+            volume_data["fastpath"] = fastpath_good?(volume_data)
             
             # Handle volume operations and status
             if vol["Operations"].any?
-              volume_data[:health] = vol["Status"]["Health"] ? vol["Status"]["Health"] : "N/A"
-              volume_data[:progress] = vol["Operations"].first["PercentageComplete"]
-              volume_data[:message] = vol["Operations"].first["OperationName"]     
-            elsif vol["Status"]["Health"] == "OK"
-              volume_data[:health] = "OK"
-              volume_data[:progress] = nil
-              volume_data[:message] = nil
+              volume_data["health"] = vol.dig("Status", "Health") || "N/A"
+              volume_data["progress"] = vol["Operations"].first["PercentageComplete"]
+              volume_data["message"] = vol["Operations"].first["OperationName"]     
+            elsif vol.dig("Status", "Health") == "OK"
+              volume_data["health"] = "OK"
+              volume_data["progress"] = nil
+              volume_data["message"] = nil
             else
-              volume_data[:health] = "?"
-              volume_data[:progress] = nil
-              volume_data[:message] = nil
+              volume_data["health"] = "?"
+              volume_data["progress"] = nil
+              volume_data["message"] = nil
             end
             
-            # Create the RecursiveOpenStruct after all properties are set
-            RecursiveOpenStruct.new(volume_data, recurse_over_arrays: true)
+            # Return the hash directly
+            volume_data
           end
           
-          return volumes.sort_by { |d| d.name }
+          return volumes.sort_by { |d| d["name"] }
         rescue JSON::ParserError
           raise Error, "Failed to parse volumes response: #{response.body}"
         end
@@ -187,9 +174,9 @@ module IDRAC
       return "disabled" unless volume
       
       # Modern firmware check handled by caller
-      if volume[:write_cache_policy] == "WriteThrough" && 
-         volume[:read_cache_policy] == "NoReadAhead" && 
-         volume[:stripe_size] == "64KB"
+      if volume["write_cache_policy"] == "WriteThrough" && 
+         volume["read_cache_policy"] == "NoReadAhead" && 
+         volume["stripe_size"] == "64KB"
         return "enabled"
       else
         return "disabled"
@@ -367,7 +354,7 @@ module IDRAC
 
     # Check if all physical disks are Self-Encrypting Drives
     def all_seds?(drives)
-      drives.all? { |d| d.encryption_ability == "SelfEncryptingDrive" }
+      drives.all? { |d| d["encryption_ability"] == "SelfEncryptingDrive" }
     end
 
     # Check if the system is ready for SED operations
@@ -402,5 +389,15 @@ module IDRAC
         end
       end
     end
+
+    # Check if the controller is capable of encryption
+    def controller_encryption_capable?(controller)
+      controller.dig("encryption_capability") =~ /localkey/i
+    end
+
+    # Check if controller encryption is enabled
+    def controller_encryption_enabled?(controller)
+      controller.dig("encryption_mode") =~ /localkey/i
+    end
   end
-end 
+end

data/lib/idrac/system.rb

@@ -1,6 +1,5 @@
 require 'json'
 require 'colorize'
-require 'recursive-open-struct'
 
 module IDRAC
   module System
@@ -11,28 +10,25 @@ module IDRAC
       if response.status == 200
         begin
           data = JSON.parse(response.body)
+          
           memory = data["Members"].map do |m|
             dimm_name = m["Name"] # e.g. DIMM A1
-            bank, index = /DIMM ([A-Z])(\d+)/.match(dimm_name).captures rescue [nil, nil]
-            
-            puts "DIMM: #{m["Model"]} #{m["Name"]} > #{m["CapacityMiB"]}MiB > #{m["Status"]["Health"]} > #{m["OperatingSpeedMhz"]}MHz > #{m["PartNumber"]} / #{m["SerialNumber"]}"
+            bank, index = /DIMM ([A-Z])(\d+)/.match(dimm_name).captures
             
-            memory_data = { 
-              model: m["Model"], 
-              name: m["Name"], 
-              capacity_bytes: m["CapacityMiB"].to_i.megabyte, 
-              health: m["Status"]["Health"] ? m["Status"]["Health"] : "N/A", 
-              speed_mhz: m["OperatingSpeedMhz"], 
-              part_number: m["PartNumber"], 
-              serial: m["SerialNumber"],
-              bank: bank,
-              index: index.to_i
+            {
+              "model" => m["Model"], 
+              "name" => m["Name"], 
+              "capacity_bytes" => m["CapacityMiB"].to_i * 1024 * 1024, 
+              "health" => m.dig("Status","Health") || "N/A", 
+              "speed_mhz" => m["OperatingSpeedMhz"], 
+              "part_number" => m["PartNumber"], 
+              "serial" => m["SerialNumber"],
+              "bank" => bank,
+              "index" => index.to_i
             }
-            
-            RecursiveOpenStruct.new(memory_data, recurse_over_arrays: true)
           end
           
-          return memory.sort_by { |m| [m.bank || "Z", m.index || 999] }
+          return memory.sort_by { |m| [m["bank"] || "Z", m["index"] || 999] }
         rescue JSON::ParserError
           raise Error, "Failed to parse memory response: #{response.body}"
         end
@@ -51,19 +47,17 @@ module IDRAC
           puts "Power Supplies".green
           
           psus = data["PowerSupplies"].map do |psu|
-            puts "PSU: #{psu["Name"]} > #{psu["PowerInputWatts"]}W > #{psu["Status"]["Health"]}"
-            psu_data = { 
-              name: psu["Name"], 
-              voltage: psu["LineInputVoltage"], 
-              voltage_human: psu["LineInputVoltageType"], # AC240V
-              watts: psu["PowerInputWatts"],
-              part: psu["PartNumber"],
-              model: psu["Model"],
-              serial: psu["SerialNumber"],
-              status: psu["Status"]["Health"],
+            puts "PSU: #{psu["Name"]} > #{psu["PowerInputWatts"]}W > #{psu.dig("Status", "Health")}"
+            {
+              "name" => psu["Name"], 
+              "voltage" => psu["LineInputVoltage"], 
+              "voltage_human" => psu["LineInputVoltageType"], # AC240V
+              "watts" => psu["PowerInputWatts"],
+              "part" => psu["PartNumber"],
+              "model" => psu["Model"],
+              "serial" => psu["SerialNumber"],
+              "status" => psu.dig("Status", "Health")
             }
-            
-            RecursiveOpenStruct.new(psu_data, recurse_over_arrays: true)
           end
           
           return psus
@@ -88,15 +82,13 @@ module IDRAC
             data = JSON.parse(response.body)
             
             fans = data["Fans"].map do |fan|
-              puts "Fan: #{fan["Name"]} > #{fan["Reading"]} > #{fan["Status"]["Health"]}"
-              fan_data = { 
-                name: fan["Name"], 
-                rpm: fan["Reading"],
-                serial: fan["SerialNumber"],
-                status: fan["Status"]["Health"]
+              puts "Fan: #{fan["Name"]} > #{fan["Reading"]} > #{fan.dig("Status", "Health")}"
+              {
+                "name" => fan["Name"], 
+                "rpm" => fan["Reading"],
+                "serial" => fan["SerialNumber"],
+                "status" => fan.dig("Status", "Health")
               }
-              
-              RecursiveOpenStruct.new(fan_data, recurse_over_arrays: true)
             end
             
             return fans
@@ -222,7 +214,7 @@ module IDRAC
           
           idrac = {
             "name" => data["Id"],
-            "status" => data["Status"]["Health"] == 'OK' ? 'Up' : 'Down',
+            "status" => data.dig("Status", "Health") == 'OK' ? 'Up' : 'Down',
             "mac" => data["MACAddress"],
             "mask" => data["IPv4Addresses"].first["SubnetMask"],
             "ipv4" => data["IPv4Addresses"].first["Address"],
@@ -293,15 +285,15 @@ module IDRAC
     def nics_to_pci(nics, pci_devices)
       # Filter for Mellanox network controllers
       mellanox_pci = pci_devices.select do |dev| 
-        dev[:device_class] =~ /NetworkController/ && dev[:manufacturer] =~ /Mellanox/
+        dev['device_class'] =~ /NetworkController/ && dev['manufacturer'] =~ /Mellanox/
       end
       
       # Create mapping of NIC names to PCI IDs
       mapping = {}
       mellanox_pci.each do |dev|
-        if dev[:nic] && dev[:nic] =~ /.*\/([^\/\-]+-\d+)/
+        if dev['nic'] && dev['nic'] =~ /.*\/([^\/\-]+-\d+)/
           nic = $1  # e.g. NIC.Slot.1-1
-          if dev[:id] =~ /^(\d+)-\d+-\d/
+          if dev['id'] =~ /^(\d+)-\d+-\d/
             pci_bus = $1  # e.g. 59
             mapping[nic] = pci_bus
           end
@@ -332,6 +324,22 @@ module IDRAC
       return nics_with_pci
     end
 
+    # Kind of like a NIC, but serves a different purpose.
+    def idrac_interface
+      response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/EthernetInterfaces/iDRAC.Embedded.1%23NIC.1")
+      idrac_data = JSON.parse(response.body)
+      {
+        "name"   => idrac_data["Id"],
+        "status" => idrac_data.dig("Status", "Health") == 'OK' ? 'Up' : 'Down',
+        "mac"    => idrac_data["MACAddress"],
+        "mask"   => idrac_data["IPv4Addresses"].first["SubnetMask"],
+        "ipv4"   => idrac_data["IPv4Addresses"].first["Address"],
+        "origin" => idrac_data["IPv4Addresses"].first["AddressOrigin"], # DHCP or Static
+        "port"   => nil,
+        "speed_mbps" => idrac_data["SpeedMbps"],
+        "kind"   => "ethernet"
+      }
+    end
     # Get system identification information
     def system_info
       response = authenticated_request(:get, "/redfish/v1")
@@ -342,42 +350,42 @@ module IDRAC
           
           # Initialize return hash with defaults
           info = {
-            is_dell: false,
-            is_ancient_dell: false,
-            product: data["Product"] || "Unknown",
-            service_tag: nil,
-            model: nil,
-            idrac_version: data["RedfishVersion"],
-            firmware_version: nil
+            "is_dell" => false,
+            "is_ancient_dell" => false,
+            "product" => data["Product"] || "Unknown",
+            "service_tag" => nil,
+            "model" => nil,
+            "idrac_version" => data["RedfishVersion"],
+            "firmware_version" => nil
           }
           
           # Check if it's a Dell iDRAC
           if data["Product"] == "Integrated Dell Remote Access Controller"
-            info[:is_dell] = true
+            info["is_dell"] = true
             
             # Get service tag from Dell OEM data
-            info[:service_tag] = data.dig("Oem", "Dell", "ServiceTag")
+            info["service_tag"] = data.dig("Oem", "Dell", "ServiceTag")
             
             # Get firmware version - try both common locations
-            info[:firmware_version] = data["FirmwareVersion"] || data.dig("Oem", "Dell", "FirmwareVersion")
+            info["firmware_version"] = data["FirmwareVersion"] || data.dig("Oem", "Dell", "FirmwareVersion")
             
             # Get additional system information
             system_response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1")
             if system_response.status == 200
               system_data = JSON.parse(system_response.body)
-              info[:model] = system_data["Model"]
+              info["model"] = system_data["Model"]
             end
           
-            return RecursiveOpenStruct.new(info, recurse_over_arrays: true)
+            return info
           else
             # Try to handle ancient Dell models where Product is null or non-standard
             if data["Product"].nil? || data.dig("Oem", "Dell")
-              info[:is_ancient_dell] = true
-              return RecursiveOpenStruct.new(info, recurse_over_arrays: true)
+              info["is_ancient_dell"] = true
+              return info
             end
           end
           
-          return RecursiveOpenStruct.new(info, recurse_over_arrays: true)
+          return info
         rescue JSON::ParserError
           raise Error, "Failed to parse system information: #{response.body}"
         end
@@ -395,14 +403,14 @@ module IDRAC
           data = JSON.parse(response.body)
           
           summary = {
-            count: data.dig("ProcessorSummary", "Count"),
-            model: data.dig("ProcessorSummary", "Model"),
-            cores: data.dig("ProcessorSummary", "CoreCount"),
-            threads: data.dig("ProcessorSummary", "LogicalProcessorCount"),
-            status: data.dig("ProcessorSummary", "Status", "Health")
+            "count" => data.dig("ProcessorSummary", "Count"),
+            "model" => data.dig("ProcessorSummary", "Model"),
+            "cores" => data.dig("ProcessorSummary", "CoreCount"),
+            "threads" => data.dig("ProcessorSummary", "LogicalProcessorCount"),
+            "status" => data.dig("ProcessorSummary", "Status", "Health")
           }
           
-          return RecursiveOpenStruct.new(summary, recurse_over_arrays: true)
+          return summary
         rescue JSON::ParserError
           raise Error, "Failed to parse processor information: #{response.body}"
         end
@@ -420,14 +428,14 @@ module IDRAC
           data = JSON.parse(response.body)
           
           health = {
-            overall: data.dig("Status", "HealthRollup"),
-            system: data.dig("Status", "Health"),
-            processor: data.dig("ProcessorSummary", "Status", "Health"),
-            memory: data.dig("MemorySummary", "Status", "Health"),
-            storage: data.dig("Storage", "Status", "Health")
+            "overall" => data.dig("Status", "HealthRollup"),
+            "system" => data.dig("Status", "Health"),
+            "processor" => data.dig("ProcessorSummary", "Status", "Health"),
+            "memory" => data.dig("MemorySummary", "Status", "Health"),
+            "storage" => data.dig("Storage", "Status", "Health")
           }
           
-          return RecursiveOpenStruct.new(health, recurse_over_arrays: true)
+          return health
         rescue JSON::ParserError
           raise Error, "Failed to parse system health information: #{response.body}"
         end

data/lib/idrac/version.rb

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

data/lib/idrac.rb

@@ -7,7 +7,6 @@ require 'faraday/multipart'
 require 'base64'
 require 'uri'
 require 'colorize'
-require 'recursive-open-struct'
 require 'active_support'
 require 'active_support/core_ext'
 # If dev, required debug

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.5.10
+  version: 0.6.0
 platform: ruby
 authors:
 - Jonathan Siegel
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -149,26 +150,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.1.0
-- !ruby/object:Gem::Dependency
-  name: recursive-open-struct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -297,6 +278,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: http://github.com
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -311,7 +293,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: API Client for Dell iDRAC
 test_files: []