idrac 0.1.91 → 0.3.1

data/lib/idrac/system.rb

@@ -0,0 +1,383 @@
+require 'json'
+require 'colorize'
+
+module IDRAC
+  module SystemComponentMethods
+    # Get memory information
+    def memory
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/Memory?$expand=*($levels=1)")
+      
+      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"]}"
+            
+            { 
+              "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
+            }
+          end
+          
+          return memory.sort_by { |a| [a["bank"] || "Z", a["index"] || 999] }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse memory response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get memory. Status code: #{response.status}"
+      end
+    end
+
+    # Get power supply information
+    def psus
+      response = authenticated_request(:get, "/redfish/v1/Chassis/System.Embedded.1/Power")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          puts "Power Supplies".green
+          
+          psus = data["PowerSupplies"].map do |psu|
+            puts "PSU: #{psu["Name"]} > #{psu["PowerInputWatts"]}W > #{psu["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["Status"]["Health"],
+            }
+          end
+          
+          return psus
+        rescue JSON::ParserError
+          raise Error, "Failed to parse PSU response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get PSUs. Status code: #{response.status}"
+      end
+    end
+
+    # Get fan information
+    def fans
+      tries = 0
+      max_tries = 3
+      
+      while tries < max_tries
+        begin
+          response = authenticated_request(:get, "/redfish/v1/Chassis/System.Embedded.1/Thermal?$expand=*($levels=1)")
+          
+          if response.status == 200
+            data = JSON.parse(response.body)
+            
+            fans = data["Fans"].map do |fan|
+              puts "Fan: #{fan["Name"]} > #{fan["Reading"]} > #{fan["Status"]["Health"]}"
+              { 
+                "name" => fan["Name"], 
+                "rpm" => fan["Reading"],
+                "serial" => fan["SerialNumber"],
+                "status" => fan["Status"]["Health"]
+              }
+            end
+            
+            return fans
+          elsif response.status.between?(400, 499)
+            # Check if system is powered off
+            power_response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1?$select=PowerState")
+            if power_response.status == 200 && JSON.parse(power_response.body)["PowerState"] == "Off"
+              puts "WARN: System is off. Fans are not available.".yellow
+              return []
+            end
+          end
+        rescue => e
+          puts "WARN: Error getting fans: #{e.message}".yellow
+        end
+        
+        tries += 1
+        puts "Failed to get fans. Retrying #{tries}/#{max_tries}.".red if tries < max_tries
+        sleep 10
+      end
+      
+      puts "Failed to get fans after #{max_tries} tries".red
+      return []
+    end
+
+    # Get NIC information
+    def nics
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/NetworkAdapters?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          adapters_data = JSON.parse(response.body)
+          
+          # Determine iDRAC version for different port paths
+          idrac_version_response = authenticated_request(:get, "/redfish/v1")
+          idrac_version_data = JSON.parse(idrac_version_response.body)
+          server = idrac_version_data["RedfishVersion"] || idrac_version_response.headers["server"]
+          
+          is_idrac9 = case server.to_s.downcase
+                      when /idrac\/9/
+                        true
+                      when /idrac\/8/
+                        false
+                      when /appweb\/4.5/
+                        false
+                      else
+                        # Default to newer format for unknown versions
+                        true
+                      end
+          
+          port_part = is_idrac9 ? 'Ports' : 'NetworkPorts'
+          
+          nics = adapters_data["Members"].map do |adapter|
+            path = "#{adapter["@odata.id"].split("v1/").last}/#{port_part}?$expand=*($levels=1)"
+            ports_response = authenticated_request(:get, "/redfish/v1/#{path}")
+            
+            if ports_response.status == 200
+              ports_data = JSON.parse(ports_response.body)
+              
+              ports = ports_data["Members"].map do |nic|
+                if is_idrac9
+                  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"
+                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"],
+                "manufacturer" => adapter["Manufacturer"],
+                "model" => adapter["Model"],
+                "part_number" => adapter["PartNumber"],
+                "serial" => adapter["SerialNumber"],
+                "ports" => ports
+              }
+            else
+              # Return adapter info without ports if we can't get port details
+              {
+                "name" => adapter["Id"],
+                "manufacturer" => adapter["Manufacturer"],
+                "model" => adapter["Model"],
+                "part_number" => adapter["PartNumber"],
+                "serial" => adapter["SerialNumber"],
+                "ports" => []
+              }
+            end
+          end
+          
+          return nics
+        rescue JSON::ParserError
+          raise Error, "Failed to parse NICs response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get NICs. Status code: #{response.status}"
+      end
+    end
+
+    # Get iDRAC network information
+    def idrac_network
+      response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/EthernetInterfaces/iDRAC.Embedded.1%23NIC.1")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          idrac = {
+            "name" => data["Id"],
+            "status" => data["Status"]["Health"] == 'OK' ? 'Up' : 'Down',
+            "mac" => data["MACAddress"],
+            "mask" => data["IPv4Addresses"].first["SubnetMask"],
+            "ipv4" => data["IPv4Addresses"].first["Address"],
+            "origin" => data["IPv4Addresses"].first["AddressOrigin"], # DHCP or Static
+            "port" => nil,
+            "speed_mbps" => data["SpeedMbps"],
+            "kind" => "ethernet"
+          }
+          
+          return idrac
+        rescue JSON::ParserError
+          raise Error, "Failed to parse iDRAC network response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get iDRAC network. Status code: #{response.status}"
+      end
+    end
+
+    # Get PCI device information
+    def pci_devices
+      response = authenticated_request(:get, "/redfish/v1/Chassis/System.Embedded.1/PCIeDevices?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          pci = data["Members"].map do |stub|
+            manufacturer = stub["Manufacturer"]
+            
+            # Get PCIe function details if available
+            pcie_function = nil
+            if stub.dig("Links", "PCIeFunctions", 0, "@odata.id")
+              pcie_function_path = stub.dig("Links", "PCIeFunctions", 0, "@odata.id").split("v1/").last
+              function_response = authenticated_request(:get, "/redfish/v1/#{pcie_function_path}")
+              
+              if function_response.status == 200
+                pcie_function = JSON.parse(function_response.body)
+              end
+            end
+            
+            # Create device info with available data
+            device_info = {
+              device_class: pcie_function ? pcie_function["DeviceClass"] : nil,
+              manufacturer: manufacturer,
+              name: stub["Name"],
+              description: stub["Description"],
+              id: pcie_function ? pcie_function["Id"] : stub["Id"],
+              slot_type: pcie_function ? pcie_function.dig("Oem", "Dell", "DellPCIeFunction", "SlotType") : nil,
+              bus_width: pcie_function ? pcie_function.dig("Oem", "Dell", "DellPCIeFunction", "DataBusWidth") : nil,
+              nic: pcie_function ? pcie_function.dig("Links", "EthernetInterfaces", 0, "@odata.id") : nil
+            }
+            
+            puts "PCI Device: #{device_info[:name]} > #{device_info[:manufacturer]} > #{device_info[:device_class]} > #{device_info[:description]} > #{device_info[:id]}"
+            
+            device_info
+          end
+          
+          return pci
+        rescue JSON::ParserError
+          raise Error, "Failed to parse PCI devices response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get PCI devices. Status code: #{response.status}"
+      end
+    end
+
+    # Map NICs to PCI bus IDs for Mellanox cards
+    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/
+      end
+      
+      # Create mapping of NIC names to PCI IDs
+      mapping = {}
+      mellanox_pci.each do |dev|
+        if dev[:nic] && dev[:nic] =~ /.*\/([^\/\-]+-\d+)/
+          nic = $1  # e.g. NIC.Slot.1-1
+          if dev[:id] =~ /^(\d+)-\d+-\d/
+            pci_bus = $1  # e.g. 59
+            mapping[nic] = pci_bus
+          end
+        end
+      end
+      
+      # Add PCI bus info to each NIC port
+      nics_with_pci = nics.map do |nic|
+        nic_with_pci = nic.dup
+        
+        if nic_with_pci["ports"]
+          nic_with_pci["ports"] = nic_with_pci["ports"].map do |port|
+            port_with_pci = port.dup
+            pci_bus = mapping[port["name"]]
+            
+            if pci_bus
+              port_with_pci["pci"] = pci_bus
+              port_with_pci["linux_device"] = "enp#{pci_bus}s0np0" # e.g. enp3s0np0
+            end
+            
+            port_with_pci
+          end
+        end
+        
+        nic_with_pci
+      end
+      
+      return nics_with_pci
+    end
+
+    # Get system event logs
+    def system_event_logs
+      response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/Logs/Sel?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          logs = data["Members"].map do |log|
+            puts "#{log['Id']} : #{log['Created']} : #{log['Message']} : #{log['Severity']}".yellow
+            log
+          end
+          
+          # Sort by creation date, newest first
+          return logs.sort_by { |log| log['Created'] }.reverse
+        rescue JSON::ParserError
+          raise Error, "Failed to parse system event logs response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get system event logs. Status code: #{response.status}"
+      end
+    end
+
+    # Clear system event logs
+    def clear_system_event_logs
+      response = authenticated_request(
+        :post, 
+        "/redfish/v1/Managers/iDRAC.Embedded.1/LogServices/Sel/Actions/LogService.ClearLog",
+        body: {}.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "System Event Logs cleared".green
+        return true
+      else
+        error_message = "Failed to clear System Event Logs. Status code: #{response.status}"
+        
+        begin
+          error_data = JSON.parse(response.body)
+          error_message += ", Message: #{error_data['error']['message']}" if error_data['error'] && error_data['error']['message']
+        rescue
+          # Ignore JSON parsing errors
+        end
+        
+        raise Error, error_message
+      end
+    end
+
+    # Get total memory in human-readable format
+    def total_memory_human(memory_data)
+      total_memory = memory_data.sum { |m| m['capacity_bytes'] }
+      "%0.2f GB" % (total_memory.to_f / 1.gigabyte)
+    end
+  end
+end 

data/lib/idrac/version.rb

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

data/lib/idrac/virtual_media.rb

@@ -0,0 +1,285 @@
+require 'json'
+require 'colorize'
+
+module IDRAC
+  module VirtualMediaMethods
+    # Get current virtual media status
+    def virtual_media
+      response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/VirtualMedia?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          media = data["Members"].map do |m|
+            if m["Inserted"]
+              puts "#{m["Name"]} #{m["ConnectedVia"]} #{m["Image"]}".green
+            else
+              puts "#{m["Name"]} #{m["ConnectedVia"]}".yellow
+            end
+            
+            action_path = m.dig("Actions", "#VirtualMedia.InsertMedia", "target")
+            
+            { 
+              device: m["Id"], 
+              inserted: m["Inserted"], 
+              image: m["Image"] || m["ConnectedVia"],
+              action_path: action_path
+            }
+          end
+          
+          return media
+        rescue JSON::ParserError
+          raise Error, "Failed to parse virtual media response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get virtual media. Status code: #{response.status}"
+      end
+    end
+
+    # Eject virtual media from a device
+    def eject_virtual_media(device: "CD")
+      media_list = virtual_media
+      
+      # Find the device to eject
+      media_to_eject = media_list.find { |m| m[:device] == device && m[:inserted] }
+      
+      if media_to_eject.nil?
+        puts "No media #{device} to eject".yellow
+        return false
+      end
+      
+      puts "Ejecting #{media_to_eject[:device]} #{media_to_eject[:image]}".yellow
+      
+      # Use the action path from the media object if available
+      path = if media_to_eject[:action_path]
+              media_to_eject[:action_path].sub(/^\/redfish\/v1\//, "").sub(/InsertMedia$/, "EjectMedia")
+             else
+              "Managers/iDRAC.Embedded.1/VirtualMedia/#{device}/Actions/VirtualMedia.EjectMedia"
+             end
+      
+      response = authenticated_request(
+        :post, 
+        "/redfish/v1/#{path}",
+        body: {}.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      case response.status
+      when 200..299
+        sleep 5 # Wait for ejection to complete
+        puts "Ejected #{media_to_eject[:device]}".green
+        return true
+      when 500..599
+        # Check if the error is "No Virtual Media devices are currently connected"
+        begin
+          error_data = JSON.parse(response.body)
+          if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"] &&
+             error_data["error"]["@Message.ExtendedInfo"].any? { |m| m["Message"] =~ /No Virtual Media devices are currently connected/ }
+            puts "No Virtual Media devices are currently connected".yellow
+            return false
+          end
+        rescue JSON::ParserError
+          # Ignore parsing errors
+        end
+        
+        puts "Failed to eject media: #{response.status}".red
+        return false
+      else
+        puts "Unexpected response code: #{response.status}".red
+        return false
+      end
+    end
+
+    # Insert virtual media (ISO)
+    def insert_virtual_media(iso_url, device: "CD")
+      raise Error, "Device must be CD or RemovableDisk" unless ["CD", "RemovableDisk"].include?(device)
+      
+      # First eject any inserted media
+      eject_virtual_media(device: device)
+      
+      # Firmware version determines which API to use
+      firmware_version = get_firmware_version.split(".")[0,2].join.to_i
+      
+      puts "Inserting media: #{iso_url}".yellow
+      
+      tries = 0
+      max_tries = 10
+      
+      while tries < max_tries
+        begin
+          # Different endpoint based on firmware version
+          path = if firmware_version >= 600
+                  "Systems/System.Embedded.1/VirtualMedia/1/Actions/VirtualMedia.InsertMedia" 
+                 else
+                  "Managers/iDRAC.Embedded.1/VirtualMedia/#{device}/Actions/VirtualMedia.InsertMedia"
+                 end
+          
+          response = authenticated_request(
+            :post, 
+            "/redfish/v1/#{path}",
+            body: { "Image": iso_url, "Inserted": true, "WriteProtected": true }.to_json,
+            headers: { 'Content-Type': 'application/json' }
+          )
+          
+          if response.status == 204 || response.status == 200
+            puts "Inserted media successfully".green
+            return true
+          end
+          
+          # Handle error responses
+          error_message = "Failed to insert media. Status code: #{response.status}"
+          begin
+            error_data = JSON.parse(response.body)
+            if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+              error_info = error_data["error"]["@Message.ExtendedInfo"].first
+              error_message += ", Message: #{error_info['Message']}"
+            end
+          rescue
+            # Ignore JSON parsing errors
+          end
+          
+          puts "#{error_message}. Retrying (#{tries + 1}/#{max_tries})...".red
+        rescue => e
+          puts "Error during insert_virtual_media: #{e.message}. Retrying (#{tries + 1}/#{max_tries})...".red
+        end
+        
+        tries += 1
+        sleep 60 # Wait before retry
+      end
+      
+      raise Error, "Failed to insert virtual media after #{max_tries} attempts"
+    end
+
+    # Set boot to virtual media once, then boot from HD
+    def set_one_time_virtual_media_boot
+      # Check firmware version to determine which API to use
+      firmware_version = get_firmware_version.split(".")[0,2].join.to_i
+      
+      if firmware_version >= 440 # Modern iDRAC
+        # Check current boot configuration
+        boot_response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1")
+        if boot_response.status == 200
+          boot_data = JSON.parse(boot_response.body)
+          enabled = boot_data['Boot']['BootSourceOverrideEnabled']
+          target = boot_data['Boot']['BootSourceOverrideTarget']
+          puts "Currently override is #{enabled} to boot from #{target}".yellow
+        end
+        
+        # Set one-time boot to CD
+        response = authenticated_request(
+          :patch, 
+          "/redfish/v1/Systems/System.Embedded.1",
+          body: { "Boot": { "BootSourceOverrideTarget": "Cd", "BootSourceOverrideEnabled": "Once" } }.to_json,
+          headers: { 'Content-Type': 'application/json' }
+        )
+        
+        if response.status.between?(200, 299)
+          puts "One-time boot to virtual media configured".green
+          return true
+        else
+          error_message = "Failed to set one-time boot. Status code: #{response.status}"
+          begin
+            error_data = JSON.parse(response.body)
+            if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+              error_info = error_data["error"]["@Message.ExtendedInfo"].first
+              error_message += ", Message: #{error_info['Message']}"
+            end
+          rescue
+            # Ignore JSON parsing errors
+          end
+          
+          raise Error, error_message
+        end
+      else
+        # For older iDRAC, we need to use the iDRAC-specific method
+        payload = { 
+          "ServerBoot.1#BootOnce": "Enabled",
+          "ServerBoot.1#FirstBootDevice": "VCD-DVD"
+        }
+        
+        response = authenticated_request(
+          :patch, 
+          "/redfish/v1/Managers/iDRAC.Embedded.1/Attributes",
+          body: payload.to_json,
+          headers: { 'Content-Type': 'application/json' }
+        )
+        
+        if response.status.between?(200, 299)
+          puts "One-time boot to virtual media configured".green
+          return true
+        else
+          error_message = "Failed to set one-time boot. Status code: #{response.status}"
+          begin
+            error_data = JSON.parse(response.body)
+            if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+              error_info = error_data["error"]["@Message.ExtendedInfo"].first
+              error_message += ", Message: #{error_info['Message']}"
+            end
+          rescue
+            # Ignore JSON parsing errors
+          end
+          
+          raise Error, error_message
+        end
+      end
+    end
+
+    # Get current boot source override settings
+    def get_boot_source_override
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          boot = data["Boot"]
+          
+          puts "Boot Source Override Configuration:".green
+          puts "  Enabled: #{boot['BootSourceOverrideEnabled']}"
+          puts "  Target: #{boot['BootSourceOverrideTarget']}"
+          puts "  Mode: #{boot['BootSourceOverrideMode']}" if boot['BootSourceOverrideMode']
+          
+          if boot["BootSourceOverrideEnabled"] != "Once" || boot["BootSourceOverrideTarget"] == "None"
+            return "None"
+          else
+            return "#{boot['BootSourceOverrideMode']} #{boot['BootSourceOverrideTarget']}"
+          end
+        rescue JSON::ParserError
+          raise Error, "Failed to parse boot source response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get boot source override. Status code: #{response.status}"
+      end
+    end
+
+    private
+
+    # Get firmware version (helper method for virtual media operations)
+    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
+  end
+end