idrac 0.5.6 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c4df0e2ba5dc5fb8bed2bfd514d2ee6ce8587cad0bf8f138021bff201c14887
-  data.tar.gz: b1cad50c169305b1369345c5bf1ee0d18d4b4c6c1f3e46c97b413e3009b295d0
+  metadata.gz: bffa45c5c7e0b67861ef0218cc20c2ff5884ed4b4ebb63a21c58ce1001c0acd5
+  data.tar.gz: 2403bede70f81efe014454654f5babe73bc2c7706902b96d1d2fdea5b763a4ff
 SHA512:
-  metadata.gz: c1dd008ed19fb33410d9ccc564bba643b2000f2a5de701568ff2ddb2cd34605a80736745745d56286e8940d37a7d06a348b9cb33227529430d7a26757a2f05a7
-  data.tar.gz: b1037ced078ac07b9629c76d00694d887b5979686fc942d105904d0c96279bc9d2d33c0cc2e863e25f5d6df1fdaa277cffb8159b18019e7303692dc431a09461
+  metadata.gz: 4ecf2f515abc4e780a4f4f302ce0dd408f95ff6ee4a73bd91df609d7fdc01aebd65ea060400225adb676f8731d4f401ee0cf9db75a106f99a70cff0ab64e4675
+  data.tar.gz: 3fd76fda921f9e1c9a0483c5302a6e64f4f3bc1231c2ad2a2849d3a16290a4270378511c96b1ffce7b545957455008a8b99fa7f259444eec82bcfb323c556632

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/storage.rb

@@ -82,8 +82,7 @@ module IDRAC
     def drives(controller)
       raise Error, "Controller not provided" unless controller
       
-      odata_id_path = controller["@odata.id"] || controller["odata_id"]
-      controller_path = odata_id_path.split("v1/").last
+      controller_path = controller["@odata.id"].split("v1/").last
       response = authenticated_request(:get, "/redfish/v1/#{controller_path}?$expand=*($levels=1)")
       
       if response.status == 200
@@ -108,7 +107,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)
@@ -129,8 +128,8 @@ module IDRAC
       
       puts "Volumes (e.g. Arrays)".green
       
-      odata_id_path = controller.dig("Volumes", "odata_id") || controller.volumes.odata_id
-      path = odata_id_path.split("v1/").last
+      v = controller["Volumes"]
+      path = v["@odata.id"].split("v1/").last
       response = authenticated_request(:get, "/redfish/v1/#{path}?$expand=*($levels=1)")
       
       if response.status == 200
@@ -404,278 +403,4 @@ module IDRAC
       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
+end 

data/lib/idrac/version.rb

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

metadata

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