idrac 0.7.1 → 0.7.2

data/lib/idrac/system_config.rb

@@ -3,106 +3,170 @@ require 'colorize'
 
 module IDRAC
   module SystemConfig
-    # Get the system configuration profile for a given target (e.g. "RAID")
-    def get_system_configuration_profile(target: "RAID")
-      tries = 0
-      location = nil
-      started_at = Time.now
+    # This assigns the iDRAC IP to be a STATIC IP.
+    def set_idrac_ip(new_ip:, new_gw:, new_nm:, vnc_password: "calvin")
+      scp = get_system_configuration_profile(target: "iDRAC")
+      pp scp
+      ## We want to access the iDRAC web server even when IPs don't match (and they won't when we port forward local host):
+      set_scp_attribute(scp, "WebServer.1#HostHeaderCheck", "Disabled")
+      ## We want VirtualMedia to be enabled so we can mount ISOs: set_scp_attribute(scp, "VirtualMedia.1#Enable", "Enabled")
+      set_scp_attribute(scp, "VirtualMedia.1#EncryptEnable", "Disabled")
+      ## We want to access VNC Server on 5901 for screenshots and without SSL:
+      set_scp_attribute(scp, "VNCServer.1#Enable", "Enabled")
+      set_scp_attribute(scp, "VNCServer.1#Port", "5901")
+      set_scp_attribute(scp, "VNCServer.1#SSLEncryptionBitLength", "Disabled")
+      # And password calvin
+      set_scp_attribute(scp, "VNCServer.1#Password", vnc_password)
+      # Disable DHCP on management NIC
+      set_scp_attribute(scp, "IPv4.1#DHCPEnable", "Disabled")
+      if drac_license_version.to_i == 8
+        # We want to use HTML for the virtual console
+        set_scp_attribute(scp, "VirtualConsole.1#PluginType", "HTML5")
+        # We want static IP for the iDRAC
+        set_scp_attribute(scp, "IPv4.1#Address", new_ip)
+        set_scp_attribute(scp, "IPv4.1#Gateway", new_gw)
+        set_scp_attribute(scp, "IPv4.1#Netmask", new_nm)
+      elsif drac_license_version.to_i == 9
+        # We want static IP for the iDRAC
+        set_scp_attribute(scp, "IPv4Static.1#Address", new_ip)
+        set_scp_attribute(scp, "IPv4Static.1#Gateway", new_gw)
+        set_scp_attribute(scp, "IPv4Static.1#Netmask", new_nm)
+        # {"Name"=>"SerialCapture.1#Enable", "Value"=>"Disabled", "Set On Import"=>"True", "Comment"=>"Read and Write"},
+      else
+        raise "Unknown iDRAC version"
+      end
+      while true
+        res = self.post(path: "Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ImportSystemConfiguration", params: {"ImportBuffer": scp.to_json, "ShareParameters": {"Target": "iDRAC"}})
+        # A successful JOB will have a location header with a job id.
+        # We can get a busy message instead if we've sent too many iDRAC jobs back-to-back, so we check for that here.
+        if res[:headers]["location"].present?
+          # We have a job id, so we're good to go.
+          break
+        else
+          # Depending on iDRAC version content-length may be present or not.
+          # res[:headers]["content-length"].blank?
+          msg = res['body']['error']['@Message.ExtendedInfo'].first['Message']
+          details = res['body']['error']['@Message.ExtendedInfo'].first['Resolution']
+          # msg     => "A job operation is already running. Retry the operation after the existing job is completed."
+          # details => "Wait until the running job is completed or delete the scheduled job and retry the operation."
+          if details =~ /Wait until the running job is completed/
+            sleep 10
+          else
+            Rails.logger.warn msg+details
+            raise "failed configuring static ip, message: #{msg}, details: #{details}"
+          end
+        end
+      end
       
-      while location.nil?
-        debug "Exporting System Configuration try #{tries+=1}..."
-        
-        response = authenticated_request(:post, 
-          "/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ExportSystemConfiguration", 
-          body: {"ExportFormat": "JSON", "ShareParameters":{"Target": target}}.to_json,
-          headers: {"Content-Type" => "application/json"}
-        )
+      # Allow some time for the iDRAC to prepare before checking the task status
+      sleep 3
+      
+      # Use handle_location to monitor task progress
+      result = handle_location(res[:headers]["location"])
+      
+      # Check if the operation succeeded
+      if result[:status] != :success
+        # Extract error details if available
+        message = result[:messages].first rescue "N/A" 
+        error = result[:error] || "Unknown error"
+        raise "Failed configuring static IP: #{message} - #{error}"
+      end
+      
+      # Finally, let's update our configuration to reflect the new port:
+      self.idrac
+      return true
+    end
 
-        if response.status == 400
-          debug "Failed exporting system configuration: #{response.body}", 1, :red
-          raise Error, "Failed exporting system configuration profile"
-        elsif response.status.between?(401, 599)
-          debug "Failed exporting system configuration: #{response.body}", 1, :red
-          
-          # Parse error response
-          error_data = JSON.parse(response.body) rescue nil
+    # Wait for a task to complete
+    def wait_for_task(task_id)
+      task = nil
+      
+      begin
+        loop do
+          task_response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks/#{task_id}")
           
-          if error_data && error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
-            message_info = error_data["error"]["@Message.ExtendedInfo"]
+          case task_response.status
+            # 200-299
+          when 200..299
+            task = JSON.parse(task_response.body)
+
+            if task["TaskState"] != "Running"
+              break
+            end
             
-            # Check for specific error conditions
-            if message_info.any? { |m| m["Message"] =~ /existing configuration job is already in progress/ }
-              debug "Existing configuration job is already in progress, retrying...", 1, :yellow
-              sleep 30
-            elsif message_info.any? { |m| m["Message"] =~ /job operation is already running/ }
-              debug "Existing job operation is already in progress, retrying...", 1, :yellow
-              sleep 60
-            else
-              # Detailed error info for debugging
-              debug "*" * 80, 1, :red
-              debug "Headers: #{response.headers.inspect}", 1, :red
-              debug "Body: #{response.body}", 1, :yellow
-              
-              # Extract the first error message if available
-              error_message = message_info.first["Message"] rescue "Unknown error"
-              debug "Error: #{error_message}", 1, :red
-              
-              raise Error, "Failed to export SCP: #{error_message}"
+            # Extract percentage complete if available
+            percent_complete = nil
+            if task["Oem"] && task["Oem"]["Dell"] && task["Oem"]["Dell"]["PercentComplete"]
+              percent_complete = task["Oem"]["Dell"]["PercentComplete"]
+              debug "Task progress: #{percent_complete}% complete", 1
             end
+            
+            debug "Waiting for task to complete...: #{task["TaskState"]} #{task["TaskStatus"]}", 1
+            sleep 5
           else
-            raise Error, "Failed to export SCP with status #{response.status}"
+            return { 
+              status: :failed, 
+              error: "Failed to check task status: #{task_response.status} - #{task_response.body}" 
+            }
           end
+        end
+        
+        # Check final task state
+        if task["TaskState"] == "Completed" && task["TaskStatus"] == "OK"
+          debugger
+          return { status: :success }
+        elsif task["SystemConfiguration"] # SystemConfigurationProfile requests yield a 202 with a SystemConfiguration key
+          return task
         else
-          # Success path - extract location header
-          location = response.headers["location"]
+          # For debugging purposes
+          debug task.inspect, 1, :yellow
           
-          if location.nil? || location.empty?
-            raise Error, "Empty location header in response: #{response.headers.inspect}"
+          # Extract any messages from the response
+          messages = []
+          if task["Messages"] && task["Messages"].is_a?(Array)
+            messages = task["Messages"].map { |m| m["Message"] }.compact
           end
+          
+          return { 
+            status: :failed, 
+            task_state: task["TaskState"], 
+            task_status: task["TaskStatus"],
+            messages: messages,
+            error: messages.first || "Task failed with state: #{task["TaskState"]}"
+          }
         end
-
-        # Progress reporting
-        minutes_elapsed = ((Time.now - started_at).to_f / 60).to_i
-        debug "Waiting for export to complete... #{minutes_elapsed} minutes", 1, :yellow
-        
-        # Exponential backoff
-        sleep 2**[tries, 6].min # Cap at 64 seconds
-        
-        if tries > 10
-          raise Error, "Failed exporting SCP after #{tries} tries, location: #{location}"
-        end
+      rescue => e
+        debugger
+        return { status: :error, error: "Exception monitoring task: #{e.message}" }
       end
+    end
 
-      # Extract job ID from location
-      job_id = location.split("/").last
+    # Handle location header and determine whether to use wait_for_job or wait_for_task
+    def handle_location(location)
+      return nil if location.nil? || location.empty?
       
-      # Poll for job completion
-      job_complete = false
-      scp = nil
+      # Extract the ID from the location
+      id = location.split("/").last
       
-      while !job_complete
-        job_response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks/#{job_id}")
-        
-        if job_response.status == 200
-          job_data = JSON.parse(job_response.body)
-          
-          if ["Running", "Pending", "New"].include?(job_data["TaskState"])
-            debug "Job status: #{job_data["TaskState"]}, waiting...", 2
-            sleep 3
-          else
-            job_complete = true
-            scp = job_data
-            
-            # Verify we have the system configuration data
-            unless scp["SystemConfiguration"]
-              raise Error, "Failed exporting SCP, taskstate: #{scp["TaskState"]}, taskstatus: #{scp["TaskStatus"]}"
-            end
-          end
-        else
-          raise Error, "Failed to check job status: #{job_response.status} - #{job_response.body}"
-        end
+      # Determine if it's a task or job based on the URL pattern
+      if location.include?("/TaskService/Tasks/")
+        wait_for_task(id)
+      else
+        # Assuming it's a job
+        wait_for_job(id)
       end
-      
+    end
+
+    # Get the system configuration profile for a given target (e.g. "RAID")
+    def get_system_configuration_profile(target: "RAID")
+      debug "Exporting System Configuration..."
+      response = authenticated_request(:post, 
+        "/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ExportSystemConfiguration", 
+        body: {"ExportFormat": "JSON", "ShareParameters":{"Target": target}}.to_json,
+        headers: {"Content-Type" => "application/json"}
+      )
+      scp = handle_location(response.headers["location"])
+      raise(Error, "Failed exporting SCP, taskstate: #{scp["TaskState"]}, taskstatus: #{scp["TaskStatus"]}") unless scp["SystemConfiguration"]
       return scp
     end
 
@@ -207,61 +271,21 @@ module IDRAC
         return { status: :failed, error: "Failed importing SCP: #{response.body}" }
       end
       
-      # Get the job location
-      job_location = response.headers["location"]
-      if job_location.nil? || job_location.empty?
-        debug response.inspect, 1, :blue
-        return { status: :failed, error: "Failed importing SCP... invalid iDRAC response" }
-      end
-      
-      # Extract job ID and monitor the task
-      job_id = job_location.split("/").last
-      task = nil
-      
-      begin
-        loop do
-          task_response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks/#{job_id}")
-          
-          if task_response.status == 200
-            task = JSON.parse(task_response.body)
-            
-            if task["TaskState"] != "Running"
-              break
-            end
-            
-            debug "Waiting for task to complete...: #{task["TaskState"]} #{task["TaskStatus"]}", 1
-            sleep 5
-          else
-            return { 
-              status: :failed, 
-              error: "Failed to check task status: #{task_response.status} - #{task_response.body}" 
-            }
-          end
-        end
-        
-        # Check final task state
-        if task["TaskState"] == "Completed" && task["TaskStatus"] == "OK"
-          return { status: :success }
-        else
-          # For debugging purposes
-          debug task.inspect, 1, :yellow
-          
-          # Extract any messages from the response
-          messages = []
-          if task["Messages"] && task["Messages"].is_a?(Array)
-            messages = task["Messages"].map { |m| m["Message"] }.compact
-          end
-          
-          return { 
-            status: :failed, 
-            task_state: task["TaskState"], 
-            task_status: task["TaskStatus"],
-            messages: messages,
-            error: messages.first || "Task failed with state: #{task["TaskState"]}"
-          }
+      return handle_location(response.headers["location"])
+    end
+
+    # This puts the SCP into a format that can be used by reasonable Ruby code.
+    # It's a hash of FQDDs to attributes.
+    def usable_scp(scp)
+      # { "FQDD1" => { "Name" => "Value" }, "FQDD2" => { "Name" => "Value" } }
+      scp.dig("SystemConfiguration", "Components").inject({}) do |acc, component|
+        fqdd = component["FQDD"]
+        attributes = component["Attributes"]
+        acc[fqdd] = attributes.inject({}) do |attr_acc, attr|
+          attr_acc[attr["Name"]] = attr["Value"]
+          attr_acc
         end
-      rescue => e
-        return { status: :error, error: "Exception monitoring task: #{e.message}" }
+        acc
       end
     end
 
@@ -366,4 +390,4 @@ module IDRAC
       result
     end
   end
-end 
+end 

data/lib/idrac/utility.rb

@@ -0,0 +1,60 @@
+module IDRAC
+  module Utility
+    include Debuggable
+
+    # Reset the iDRAC controller (graceful restart)
+    def reset!
+      debug "Resetting iDRAC controller...", 1
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Manager.Reset",
+        body: { "ResetType" => "GracefulRestart" }.to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "Reset command accepted, waiting for iDRAC to restart...", 1, :green
+        tries = 0
+        
+        while true
+          begin
+            debug "Checking if iDRAC is back online...", 1
+            response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1")
+            if response.status.between?(200, 299)
+              debug "iDRAC is back online!", 1, :green
+              break
+            end
+            sleep 30
+          rescue => e
+            tries += 1
+            if tries > 5
+              debug "Failed to reconnect to iDRAC after 5 attempts", 1, :red
+              return false
+            end
+            debug "No response from server... retry #{tries}/5", 1, :red
+            sleep 2 ** tries
+          end
+        end
+      else
+        begin
+          error_data = JSON.parse(response.body)
+          if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+            message = error_data["error"]["@Message.ExtendedInfo"].first["Message"]
+            debug "*" * 80, 1, :red
+            debug message, 1, :red
+            debug "*" * 80, 1, :red
+          else
+            debug "Failed to reset iDRAC. Status code: #{response.status}", 1, :red
+          end
+        rescue => e
+          debug "Failed to reset iDRAC. Status code: #{response.status}", 1, :red
+          debug "Error response: #{response.body}", 2, :red
+        end
+        return false
+      end
+      
+      true
+    end
+  end
+end 

data/lib/idrac/version.rb

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

data/lib/idrac/virtual_media.rb

@@ -12,8 +12,20 @@ module IDRAC
           data = JSON.parse(response.body)
           
           media = data["Members"].map do |m|
-            if m["Inserted"]
-              puts "#{m["Name"]} #{m["ConnectedVia"]} #{m["Image"]}".green
+            # Check if media is inserted based on multiple indicators
+            is_inserted = m["Inserted"] || 
+                          (!m["Image"].nil? && !m["Image"].empty?) || 
+                          (m["ConnectedVia"] && m["ConnectedVia"] != "NotConnected") ||
+                          (m["ImageName"] && !m["ImageName"].empty?)
+              
+            # Indicate which field is used for this iDRAC version and print it
+            puts "ImageName is used for this iDRAC version".yellow if m["ImageName"]
+            puts "Image is used for this iDRAC version".yellow if m["Image"]
+            puts "ConnectedVia is used for this iDRAC version".yellow if m["ConnectedVia"]
+            puts "Inserted is used for this iDRAC version".yellow if m["Inserted"]
+
+            if is_inserted
+              puts "#{m["Name"]} #{m["ConnectedVia"]} #{m["Image"] || m["ImageName"]}".green
             else
               puts "#{m["Name"]} #{m["ConnectedVia"]}".yellow
             end
@@ -22,8 +34,8 @@ module IDRAC
             
             { 
               device: m["Id"], 
-              inserted: m["Inserted"], 
-              image: m["Image"] || m["ConnectedVia"],
+              inserted: is_inserted, 
+              image: m["Image"] || m["ImageName"] || m["ConnectedVia"],
               action_path: action_path
             }
           end
@@ -64,31 +76,9 @@ module IDRAC
         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
+
+      handle_response(response)
+      response.status.between?(200, 299)
     end
 
     # Insert virtual media (ISO)

data/lib/idrac.rb

@@ -53,4 +53,6 @@ require 'idrac/virtual_media'
 require 'idrac/boot'
 require 'idrac/license'
 require 'idrac/system_config'
+require 'idrac/utility'
+# Client include must come last:
 require 'idrac/client'

metadata

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