idrac 0.5.4 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11b28d37156ee3d58ef6a804a016cc6ca35f6a4e7c4e158c93fe86c0053398f0
-  data.tar.gz: c69c297450fb2715873e3dbd66f2779d3487ce1fecfca9a4032a7d917d87f8c6
+  metadata.gz: 7c4df0e2ba5dc5fb8bed2bfd514d2ee6ce8587cad0bf8f138021bff201c14887
+  data.tar.gz: b1cad50c169305b1369345c5bf1ee0d18d4b4c6c1f3e46c97b413e3009b295d0
 SHA512:
-  metadata.gz: f0beadf7041ca23371999f125d536c25972a615092baf045fdb2694d3c15e2ea28c9f063943e1f8df67065855f26cca23e138622b2f80fba0c8bc8b575c8215c
-  data.tar.gz: c88e403f07b030a238f999498c3da04fa5b3908713d469c4e52ed28ea8ac310ec018c9a6be519695d054358a1603045d4a8785d94d029e07b90cdcbf6445a1c5
+  metadata.gz: c1dd008ed19fb33410d9ccc564bba643b2000f2a5de701568ff2ddb2cd34605a80736745745d56286e8940d37a7d06a348b9cb33227529430d7a26757a2f05a7
+  data.tar.gz: b1037ced078ac07b9629c76d00694d887b5979686fc942d105904d0c96279bc9d2d33c0cc2e863e25f5d6df1fdaa277cffb8159b18019e7303692dc431a09461

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/lib/idrac/client.rb

@@ -302,6 +302,33 @@ module IDRAC
       end
     end
 
+    def get_firmware_version
+      response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1?$select=FirmwareVersion")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          return data["FirmwareVersion"]
+        rescue JSON::ParserError
+          raise Error, "Failed to parse firmware version response: #{response.body}"
+        end
+      else
+        # Try again without the $select parameter for older firmware
+        response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1")
+        
+        if response.status == 200
+          begin
+            data = JSON.parse(response.body)
+            return data["FirmwareVersion"]
+          rescue JSON::ParserError
+            raise Error, "Failed to parse firmware version response: #{response.body}"
+          end
+        else
+          raise Error, "Failed to get firmware version. Status code: #{response.status}"
+        end
+      end
+    end
+
     # Execute a block with automatic retries
     # @param max_retries [Integer] Maximum number of retry attempts
     # @param initial_delay [Integer] Initial delay in seconds between retries (increases exponentially)

data/lib/idrac/storage.rb

@@ -82,7 +82,8 @@ module IDRAC
     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
@@ -107,7 +108,7 @@ module IDRAC
               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"]
+              odata_id: body["@odata.id"]
             }
             
             RecursiveOpenStruct.new(drive_data, recurse_over_arrays: true)
@@ -128,8 +129,8 @@ module IDRAC
       
       puts "Volumes (e.g. Arrays)".green
       
-      v = controller["Volumes"]
-      path = v["@odata.id"].split("v1/").last
+      odata_id_path = controller.dig("Volumes", "odata_id") || controller.volumes.odata_id
+      path = odata_id_path.split("v1/").last
       response = authenticated_request(:get, "/redfish/v1/#{path}?$expand=*($levels=1)")
       
       if response.status == 200
@@ -403,4 +404,278 @@ module IDRAC
       end
     end
   end
-end 
+end 
+=begin
+  def controller_encryption_capable?
+    self.meta.dig("controller", "Oem", "Dell", "DellController", "EncryptionCapability") =~ /localkey/i # "LocalKeyManagementAndSecureEnterpriseKeyManagerCapable"
+  end
+  def controller_encryption_enabled?
+    self.meta.dig("controller", "Oem", "Dell", "DellController", "EncryptionMode") =~ /localkey/i
+  end
+  def drives
+    # Get the drives
+    controller_path = self.controller["@odata.id"].split("v1/").last
+    json = get(path: "#{controller_path}?$expand=*($levels=1)")["body"]["Drives"]
+    # drives = self.controller["Drives"].collect 
+    idrac_drives = json.map do |body|
+      # path = d["@odata.id"].split("v1/").last
+      # body = self.get(path: path)["body"]
+      serial = body["SerialNumber"] 
+      serial = body["Identifiers"].first["DurableName"] if serial.blank?
+      { 
+        serial: serial,
+        model: body["Model"],
+        name: body["Name"],
+        capacity_bytes: body["CapacityBytes"],
+        # Health is nil when powered off...
+        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"]
+      }
+    end
+    self.meta["drives"] = idrac_drives.sort_by { |d| d[:name] }
+    if self.save
+      self.meta["drives"]
+    else
+      false
+    end
+  end
+  def volumes
+    puts "Volumes (e.g. Arrays)".green
+    # {"@odata.id"=>"/redfish/v1/Systems/System.Embedded.1/Storage/RAID.Integrated.1-1/Volumes"}
+
+    v = self.controller["Volumes"]
+    path = v["@odata.id"].split("v1/").last
+    vols = self.get(path: path+"?$expand=*($levels=1)")["body"]  
+    volumes = vols["Members"].collect do |vol|
+      drives = vol["Links"]["Drives"]
+      volume = { 
+        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"),
+        # "Operations"=>[{"OperationName"=>"Background Initialization", "PercentageComplete"=>0}],
+        "@odata.id": vol["@odata.id"]
+      }
+      if !self.modern_firmware?
+        # Unfortunately for older idracs, to get the drive cache policies we need to do a 
+        # system_configuration_profile call AND we still don't get the right stripe size.
+        scp ||= self.get_system_configuration_profile(target: "RAID")
+        controller = self.meta["controller"]
+        scp_vol = scp["SystemConfiguration"]["Components"]
+                   .find { |comp| comp["FQDD"] == controller['Id'] }["Components"]
+                   .find { |comp| comp["FQDD"] == vol["Id"] }["Attributes"]
+        # .find { |attr| attr["Name"] == "RAIDdefaultWritePolicy" }["Value"]
+        volume[:write_cache_policy] = scp_vol.find { |attr| attr["Name"] == "RAIDdefaultWritePolicy" }["Value"]
+        volume[:read_cache_policy]  = scp_vol.find { |attr| attr["Name"] == "RAIDdefaultReadPolicy" }["Value"]
+      end
+
+
+      # Dell-specific high-performance settings for PERC:
+      # [Read more](https://www.dell.com/support/manuals/en-us/perc-h755/perc11_ug/fastpath?guid=guid-a9e90946-a41f-48ab-88f1-9ce514b4c414&lang=en-us)
+      volume[:fastpath] = self.fastpath_good?(volume)
+
+      # Not built yet:
+      #     "Status"=>{"Health"=>nil, "HealthRollup"=>nil, "State"=>"Enabled"},
+      # Dunno
+      #     "Status"=>{"Health"=>"OK", "HealthRollup"=>"OK", "State"=>"Enabled"},
+      # In progress:
+      #     "Operations"=>[{"OperationName"=>"Background Initialization", "PercentageComplete"=>0}],
+      #     "Status"=>{"Health"=>nil, "HealthRollup"=>nil, "State"=>"Enabled"},
+      if vol["Operations"].any?
+        volume[:health]   = vol["Status"]["Health"] ? vol["Status"]["Health"] : "N/A"
+        volume[:progress] = vol["Operations"].first["PercentageComplete"]
+        volume[:message]  = vol["Operations"].first["OperationName"]     
+      elsif vol["Status"]["Health"] == "OK"
+        volume[:health]   = "OK"
+        volume[:progress] = nil
+        volume[:message]  = nil
+      else
+        volume[:health]   = "?"
+        volume[:progress] = nil
+        volume[:message]  = nil
+      end
+      volume
+    end
+    self.meta["volumes"] = volumes.sort_by { |d| d[:name] }
+    self.save
+  end
+  def memory
+    expected = expected_memory
+    mem = self.get(path: "Systems/System.Embedded.1/Memory?$expand=*($levels=1)")["body"]
+    memory = mem["Members"].map do |m|
+      dimm_name = m["Name"] # e.g. DIMM A1
+      bank, index = /DIMM ([A-Z])(\d+)/.match(dimm_name).captures
+      # We expect one of our configurations:
+      # 32GB DIMMS x 32 = 1TB   # Gen III, less memory issues (we've experienced too many bad 64GB DIMMS)
+      # 64GB DIMMS x 24 = 1.5TB # Gen II
+      # 64GB DIMMS x 32 = 2TB   # Gen I
+      expected.delete(dimm_name) if expected[dimm_name] == m["CapacityMiB"] * 1.megabyte || expected[dimm_name] == m["CapacityMiB"] * 1.megabyte * 2
+      puts "DIMM: #{m["Model"]} #{m["Name"]} > #{m["CapacityMiB"]}MiB > #{m["Status"]["Health"]} > #{m["OperatingSpeedMhz"]}MHz > #{m["PartNumber"]} / #{m["SerialNumber"]}"
+      { 
+        "model" => m["Model"], 
+        "name" => m["Name"], 
+        "capacity_bytes" => m["CapacityMiB"].to_i * 1.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
+      }
+    end
+    self.meta["memory"] = memory.sort_by { |a| [a["bank"], a["index"]] }
+    if expected.any?
+      log("Missing DIMMs: #{expected.keys.join(", ")}".red)
+      puts "Missing DIMMs: #{expected.keys.join(", ")}".red
+    end
+    self.save
+  end
+  def pci(force: false)
+    # If we've already found two Mellanox cards, let's not refresh by default
+    if !force && (2 == self.meta["pci"]&.select { |p| p['manufacturer'] =~ /Mellanox/ }&.size)
+      puts "[PCI] 2 x Mellanox NICs already found. Skipping.".yellow
+      return
+    end
+    # /redfish/v1/Chassis/System.Embedded.1/PCIeDevices/59-0/PCIeFunctions/59-0-0
+    # Look at all the PCI slots and ideally identify the Mellanox cards
+    # Then match them to the 
+    devices = self.get(path: "Chassis/System.Embedded.1/PCIeDevices?$expand=*($levels=1)")["body"]
+    pci = devices["Members"].map do |stub|
+      manufacturer = stub["Manufacturer"]
+      pcie_function_path = stub.dig("Links", "PCIeFunctions", 0, "@odata.id")
+      device = self.get(path: pcie_function_path)["body"]
+
+      # If it's a network device, we can chcek the link to its PCIe details and then 
+      # NetworkController
+      puts "PCI Device: #{device["Name"]} > #{manufacturer} > #{device["DeviceClass"]} > #{device["Description"]} > #{device["Id"]}"
+      { device_class: device["DeviceClass"], # e.g. NetworkController
+        manufacturer: manufacturer,
+        name: device["Name"],
+        description: device["Description"],
+        id: device["Id"], # This is the BUS: e.g. 59-0-0 => 3b
+        slot_type: device.dig("Oem", "Dell", "DellPCIeFunction", "SlotType"),
+        bus_width: device.dig("Oem", "Dell", "DellPCIeFunction", "DataBusWidth"),
+        nic: device.dig("Links", "EthernetInterfaces", 0, "@odata.id")
+      }
+    end
+    self.meta['pci'] = pci
+    self.save
+  end
+  # Finds Mellanox cards on the bus and their NICs.
+  # [{:bus_id=>"59", :nic=>"NIC.Slot.1-1-1"}, {:bus_id=>"94", :nic=>"NIC.Slot.2-1-1"}] 
+  def nics_to_pci
+    self.nics if self.meta['nics'].blank?
+    self.pci  if self.meta['pci'].blank?
+    hsh = self.meta['pci']&.select { |n| n['device_class'] =~ /NetworkController/ && n['manufacturer'] =~ /Mellanox/ }&.inject({}) do |acc,v| 
+      nic = (v['nic'] =~ /.*\/([^\/\-]+-\d+)/; $1) # e.g. NIC.Slot.1-1 # Drop one -1 for consistency with other iDRAC
+      pci = (v['id'] =~ /^(\d+)-\d+-\d/; $1)  # e.g. 59
+      acc[nic] = pci
+      acc
+    end
+    self.meta['nics'].each do |nic|
+      nic['ports'].each do |port| 
+        pci_bus = hsh[port['name']] 
+        if pci_bus
+          port['pci'] = pci_bus
+          port['linux_device'] = "enp#{pci_bus}s0np0" # e.g. enp3s0np0
+        end
+      end
+    end
+    hsh
+  end
+  def nics
+    # There can be multiple NIC adapters, so first we enumerate them:
+    adapters = self.get(path: "Systems/System.Embedded.1/NetworkAdapters?$expand=*($levels=1)")["body"]
+    nics     = adapters["Members"].map do |adapter|
+      port_part = self.idrac_license_version.to_i == 9 ? 'Ports' : 'NetworkPorts'
+      path  = "#{adapter["@odata.id"].split("v1/").last}/#{port_part}?$expand=*($levels=1)"
+      res   = self.get(path: path)["body"]
+      ports = res["Members"].collect do |nic|
+        link_speed_mbps, mac_addr, link_status = nil, nil, nil
+        if self.idrac_license_version.to_i == 9
+          link_speed_mbps = nic['CurrentSpeedGbps'].to_i * 1000
+          mac_addr = nic['Ethernet']['AssociatedMACAddresses'].first
+          port_num = nic['PortId']
+          network_technology = nic['LinkNetworkTechnology']
+          link_status = nic['LinkStatus'] =~ /up/i ? "Up" : "Down" # Lovely, iDRAC now uses LinkUp instead of Up. :shrug:
+        else # iDRAC 8
+          link_speed_mbps = nic["SupportedLinkCapabilities"].first["LinkSpeedMbps"]
+          mac_addr        = nic["AssociatedNetworkAddresses"].first
+          port_num        = nic["PhysicalPortNumber"]
+          network_technology = nic["SupportedLinkCapabilities"].first["LinkNetworkTechnology"]
+          link_status = nic['LinkStatus']
+        end
+        puts "NIC: #{nic["Id"]} > #{mac_addr} > #{link_status} > #{port_num} > #{link_speed_mbps}Mbps"
+        { 
+          "name" => nic["Id"], 
+          "status" => link_status,
+          "mac" => mac_addr,
+          "port" => port_num,
+          "speed_mbps" => link_speed_mbps,
+          "kind" => network_technology&.downcase
+        }
+      end
+      {
+        "name" =>  adapter["Id"],                     # "NIC.Integrated.1-1",
+        "manufacturer" => adapter["Manufacturer"],    # "Mellanox Technologies",
+        "model" => adapter["Model"],                  # "MLNX 100GbE 2P ConnectX6 Adpt"
+        "part_number" => adapter["PartNumber"],       # "08AAAA",
+        "serial" => adapter["SerialNumber"],          # "TW78AAAAAAAAAA",
+        "ports" => ports
+      }
+    end
+    # Now let's parse the NICs and make sure we have a PORT for each one.
+    # Note that we set the MAC address for the MANAGEMENT port by a heuristic!!!
+    # If we ever see a 1000 Mbps port in the NIC.Integrated or NIC.Embedded, that's the Managament Port!
+    nics.each do |nic|
+      # puts nic.inspect
+      nic["ports"].each do |port|
+        # puts port.inspect
+        if port["speed_mbps"] == 1000 && 
+          (port["name"] =~ /NIC.Integrated/ || nic["name"] =~ /NIC.Embedded/) &&
+           port['status'] == 'Up' &&
+           port['kind'] == 'ethernet' &&
+           port['mac'] =~ /([0-9a-fA-F]{2}[:-]){5}([0-9a-fA-F]{2})/
+          Rails.logger.debug "Identified Management Port: #{port['name']} #{port['mac']}".blue
+          self.management_port.update(mac_addr: port["mac"])
+        end
+      end
+    end
+    self.meta["nics"] = nics
+    self.save
+  end
+  # Kind of like a NIC, but serves a different purpose.
+  def idrac
+    body = self.get(path: "Managers/iDRAC.Embedded.1/EthernetInterfaces/iDRAC.Embedded.1%23NIC.1")["body"]
+    idrac = {
+      "name"   => body["Id"],
+      "status" => body["Status"]["Health"] == 'OK' ? 'Up' : 'Down',
+      "mac"    => body["MACAddress"],
+      "mask"   => body["IPv4Addresses"].first["SubnetMask"],
+      "ipv4"   => body["IPv4Addresses"].first["Address"],
+      "origin" => body["IPv4Addresses"].first["AddressOrigin"], # DHCP or Static
+      "port"   => nil,
+      "speed_mbps" => body["SpeedMbps"],
+      "kind"   => "ethernet"
+    }
+    self.meta["idrac"] = idrac
+    self.save
+  end
+
+=end

data/lib/idrac/version.rb

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

metadata

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