idrac 0.7.1 → 0.7.2

data/lib/idrac/boot.rb

@@ -1,6 +1,31 @@
 require 'json'
 require 'colorize'
 
+########################################################
+# BIOS Configuration / Boot Order
+########################################################
+# BEWARE YE WHO ENTER HERE
+# This is the BIOS configuration and boot order section.
+# It is a dark and dangerous place, fraught with peril.
+#
+# BIOS and UEFI and iDRAC all interplay through a handful of REST API calls and
+# a labyrinth of system configuration profile settings. You must know if you are
+# in UEFI or BIOS mode to even know which calls to make and some calls "unlock"
+# only AFTER you make a switch between modes. Which requires an explicit reboot.
+#
+# Two current open issues remain:
+#  - How do you avoid booting from an installed USB with a bootable image? (workaround--wipefs the USB)
+#  - How do you boot-once to the Virtual CD, install Ubuntu, on its natural reboot step, boot to the HD. (workaround--finish install with poweroff)
+#
+# Get oriented:
+# https://github.com/dell/dellemc-openmanage-ansible-modules/issues/21
+# https://www.dell.com/support/manuals/en-us/openmanage-ansible-modules/user_guide_1_0_1/configuring-bios?guid=guid-d2d8d871-c3e1-48d1-a879-197670fe33ea&lang=en-us
+# https://www.dell.com/support/manuals/en-us/idrac7-8-lifecycle-controller-v2.40.40.40/redfish%202.40.40.40/computersystem?guid=guid-071f0516-1b31-4a4b-90ab-4f9bfcc5db4a&lang=en-us
+# https://infohub.delltechnologies.com/en-US/l/server-configuration-profiles-reference-guide/changing-the-boot-order-2/
+# https://pubs.lenovo.com/xcc-restapi/update_next_onetime_bootconfig_patch
+# https://github.com/dell/iDRAC-Redfish-Scripting/issues/186
+# https://www.dell.com/support/kbdoc/en-us/000198504/boot-device-fqdd-name-changed-in-15g-bios-uefi-boot-sequence-after-bios-update
+# https://github.com/dell/iDRAC-Redfish-Scripting/issues/116
 module IDRAC
   module Boot
     # Get BIOS boot options
@@ -70,31 +95,7 @@ module IDRAC
               headers: { 'Content-Type': 'application/json' }
             )
             
-            if response.status.between?(200, 299)
-              puts "UEFI boot mode set. A system reboot is required for changes to take effect.".green
-              
-              # Check for job creation
-              if response.headers["Location"]
-                job_id = response.headers["Location"].split("/").last
-                wait_for_job(job_id)
-              end
-              
-              return true
-            else
-              error_message = "Failed to set UEFI boot mode. 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
+            wait_for_job(response.headers["location"])
           end
         rescue JSON::ParserError
           raise Error, "Failed to parse BIOS response: #{response.body}"
@@ -103,6 +104,44 @@ module IDRAC
         raise Error, "Failed to get BIOS information. Status code: #{response.status}"
       end
     end
+=begin
+    # Servers can boot in BIOS mode or in UEFI (modern, extensible BIOS replacement) mode.
+    # We use UEFI mode.
+    # self.get(path: "Systems/System.Embedded.1/Bios/Settings?$select=BootMode")
+    res = self.get(path: "Systems/System.Embedded.1/Bios")
+    if res["body"]["Attributes"]["BootMode"] == "Uefi"
+      return { status: :success }
+    else
+      res = self.set_system_configuration_profile(scp_boot_mode_uefi, reboot: true)
+      # Then must power cycle the server
+      self.power_on!(wait: true)
+      self.power_off!(wait: true)
+      return res
+    end
+
+=end
+    def scp_boot_mode_uefi(idrac_license_version: 9)
+      opts = { "BootMode" => 'Uefi' }
+      # If we're iDRAC 9, we need enable a placeholder, otherwise we can't order the
+      # boot order until we've switched to UEFI mode.
+      # Read [about it](https://dl.dell.com/manuals/all-products/esuprt_software/esuprt_it_ops_datcentr_mgmt/dell-management-solution-resources_white-papers12_en-us.pdf).
+      # ...administrators may wish to reserve a boot entry for a fixed disk in the UEFI Boot Sequence before an OS is installed or before a physical or
+      # virtual drive has been formatted. When a HardDisk Drive Placeholder is set to Enabled, the BIOS will create a boot option for the PERC RAID
+      # (Integrated or in a PCIe slot) disk if a partition is found, even if there is no FAT filesystem present... this allows the Integrated RAID controller
+      # to be moved in the UEFI Boot Sequence prior to the OS installation
+      opts["HddPlaceholder"] = "Enabled" if idrac_license_version.to_i == 9
+      self.make_scp(fqdd: "BIOS.Setup.1-1", attributes: opts)
+    end
+    # What triggers a reboot?
+    # https://infohub.delltechnologies.com/en-US/l/server-configuration-profiles-reference-guide/host-reboot-2/
+    def set_bios(hash)
+      scp = self.make_scp(fqdd: "BIOS.Setup.1-1", attributes: hash)
+      res = self.set_system_configuration_profile(scp)
+      if res[:status] == :success
+        self.get_bios_boot_options
+      end
+      res
+    end
     
     # Set boot order (HD first)
     def set_boot_order_hd_first
@@ -165,6 +204,70 @@ module IDRAC
         raise Error, "Failed to get boot options. Status code: #{boot_options_response.status}"
       end
     end
+
+    def set_uefi_boot_cd_once_then_hd
+      boot_options = get_bios_boot_options[:boot_options]
+      # Note may have to put device into
+      # self.set_bios( { "BootMode" => 'Uefi' } )
+      # self.reboot!
+      # And then reboot before you can make the following call:
+      raid_name = boot_options.include?("RAID.Integrated.1-1") ? "RAID.Integrated.1-1" : "Unknown.Unknown.1-1"
+      raise "No RAID HD in boot options" unless boot_options.include?(raid_name)
+      bios = {
+          "BootMode" => 'Uefi',
+          "BootSeqRetry" => "Disabled",
+
+          # "UefiTargetBootSourceOverride" => 'Cd',
+          # "BootSourceOverrideTarget" => 'UefiTarget',
+          # "OneTimeBootMode"       => "OneTimeUefiBootSeq",
+
+          # One time boot order
+          # "OneTimeHddSeqDev"      => "Optical.iDRACVirtual.1-1",
+          # "OneTimeBiosBootSeqDev" => "Optical.iDRACVirtual.1-1",
+          # "OneTimeUefiBootSeqDev" => "Optical.iDRACVirtual.1-1",
+
+          # Enabled/Disabled Options
+          # "SetBootOrderDis" => "Disk.USBBack.1-1",  # Don't boot to USB if it is plugged in
+          "SetBootOrderEn"    => raid_name,
+          # "SetBootOrderFqdd1" => raid_name,
+          # "SetLegacyHddOrderFqdd1" => raid_name,
+          # "SetBootOrderFqdd2" => "Optical.iDRACVirtual.1-1",
+
+          # Permanent Boot Order
+          "HddSeq"      => raid_name,
+          "BiosBootSeq" => raid_name,
+          "UefiBootSeq" => raid_name # This is likely redundant...
+        }
+      # The usb device will have 'usb' in it:
+      usb_name = boot_options.select { |b| b =~ /usb/i }
+      bios["SetBootOrderDis"] = usb_name if usb_name.present?
+
+      set_bios(bios)
+    end
+
+    # This sets boot to HD but before that it sets the one-time boot to CD
+    # Different approach for iDRAC 8 vs 9
+    def override_boot_source
+      # For now try with all iDRAC versions
+      if self.license_version.to_i == 9
+        set_boot_order_hd_first()
+        set_one_time_virtual_media_boot()
+      else
+        scp = {"FQDD"=>"iDRAC.Embedded.1", "Attributes"=> [{"Name"=>"ServerBoot.1#BootOnce", "Value"=>"Enabled", "Set On Import"=>"True"}, {"Name"=>"ServerBoot.1#FirstBootDevice", "Value"=>"VCD-DVD", "Set On Import"=>"True"}]}
+        # set_uefi_boot_cd_once_then_hd
+        # scp = self.set_bios_boot_cd_first
+        # get_bios_boot_options # Make sure we know if the OS is calling it Unknown or RAID
+        # {"FQDD"=>"BIOS.Setup.1-1", "Attributes"=>
+        # [{"Name"=>"ServerBoot.1#BootOnce",       "Value"=>"Enabled", "Set On Import"=>"True"},
+        # {"Name"=>"ServerBoot.1#FirstBootDevice", "Value"=>"VCD-DVD", "Set On Import"=>"True"},
+        # {"Name"=>"BootSeqRetry",                 "Value"=>"Disabled", "Set On Import"=>"True"},
+        # {"Name"=>"UefiBootSeq",                  "Value"=>"Unknown.Unknown.1-1,NIC.PxeDevice.1-1,Floppy.iDRACVirtual.1-1,Optical.iDRACVirtual.1-1",
+        #  "Set On Import"=>"True"}]}
+
+        # 3.3.0 :018 > scp1 = {"FQDD"=>"BIOS.Setup.1-1", "Attributes"=> [{"Name"=>"OneTimeUefiBootSeq", "Value"=>"VCD-DVD", "Set On Import"=>"True"}, {"Name"=>"BootSeqRetry", "Value"=>"Disabled", "Set On Import"=>"True"}, {"Name"=>"UefiBootSeq", "Value"=>"Unknown.Unknown.1-1,NIC.PxeDevice.1-1", "Set On Import"=>"True"}]}
+        set_system_configuration_profile(scp) # This will cycle power and leave the device off.
+      end
+    end
     
     # Configure BIOS settings
     def configure_bios_settings(settings)
@@ -221,6 +324,60 @@ module IDRAC
       })
     end
     
+    # Check if BIOS error prompt is disabled
+    def bios_error_prompt_disabled?
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/Bios")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          if data["Attributes"] && data["Attributes"].has_key?("ErrPrompt")
+            return data["Attributes"]["ErrPrompt"] == "Disabled"
+          else
+            debug "ErrPrompt attribute not found in BIOS settings", 1, :yellow
+            return false
+          end
+        rescue JSON::ParserError
+          debug "Failed to parse BIOS response", 0, :red
+          return false
+        end
+      else
+        debug "Failed to get BIOS information. Status code: #{response.status}", 0, :red
+        return false
+      end
+    end
+
+    def bios_hdd_placeholder_enabled?
+      case self.license_version.to_i
+      when 8
+        # scp = usable_scp(get_system_configuration_profile(target: "BIOS"))
+        # scp["BIOS.Setup.1-1"]["HddPlaceholder"] == "Enabled"
+        true
+      else
+        response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/Bios")
+        json = JSON.parse(response.body)
+        raise "Error reading HddPlaceholder setup" if json&.dig('SystemConfiguration').blank?
+        json["Attributes"]["HddPlaceholder"] == "Enabled"
+      end
+    end
+
+    def bios_os_power_control_enabled?
+      case self.license_version.to_i
+      when 8
+        scp = usable_scp(get_system_configuration_profile(target: "BIOS"))
+        scp["BIOS.Setup.1-1"]["ProcCStates"] == "Enabled" &&
+          scp["BIOS.Setup.1-1"]["SysProfile"] == "PerfPerWattOptimizedOs" &&
+          scp["BIOS.Setup.1-1"]["ProcPwrPerf"] == "OsDbpm"
+      else
+        response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/Bios")
+        json = JSON.parse(response.body)
+        raise "Error reading PowerControl setup" if json&.dig('SystemConfiguration').blank?
+        json["Attributes"]["ProcCStates"] == "Enabled" &&
+          json["Attributes"]["SysProfile"] == "PerfPerWattOptimizedOs" &&
+          json["Attributes"]["ProcPwrPerf"] == "OsDbpm"
+      end
+    end
+    
     # Get iDRAC version - needed for boot management differences
     def get_idrac_version
       response = authenticated_request(:get, "/redfish/v1")
@@ -288,7 +445,6 @@ module IDRAC
           "Target": target
         }
       }
-      
       # Configure shutdown behavior
       params["ShutdownType"] = "Forced"
       params["HostPowerState"] = reboot ? "On" : "Off"
@@ -300,58 +456,9 @@ module IDRAC
         headers: { 'Content-Type': 'application/json' }
       )
       
-      if response.status.between?(200, 299)
-        # Check if we need to wait for a job
-        if response.headers["location"]
-          job_id = response.headers["location"].split("/").last
-          
-          job = wait_for_job(job_id)
-          
-          # Check for task completion status
-          if job["TaskState"] == "Completed" && job["TaskStatus"] == "OK"
-            puts "System configuration imported successfully".green
-            return true
-          else
-            # If there's an error message with a line number, surface it
-            error_message = "Failed to import system configuration"
-            
-            if job["Messages"]
-              job["Messages"].each do |m|
-                puts "#{m["Message"]} (#{m["Severity"]})".red
-                
-                # Check for line number in error message
-                if m["Message"] =~ /line (\d+)/
-                  line_num = $1.to_i
-                  lines = JSON.pretty_generate(scp).split("\n")
-                  puts "Error near line #{line_num}:".red
-                  ((line_num-3)..(line_num+1)).each do |ln|
-                    puts "#{ln}: #{lines[ln-1]}" if ln > 0 && ln <= lines.length
-                  end
-                end
-              end
-            end
-            
-            raise Error, error_message
-          end
-        else
-          puts "System configuration import started, but no job ID was returned".yellow
-          return true
-        end
-      else
-        error_message = "Failed to import system configuration. 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
+      task = wait_for_task(response.headers["location"])
+      debugger
+      return task
     end
   end
-end 
+end 

data/lib/idrac/client.rb

@@ -23,6 +23,7 @@ module IDRAC
     include Boot
     include License
     include SystemConfig
+    include Utility
 
     def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: false, direct_mode: false, auto_delete_sessions: true, retry_count: 3, retry_delay: 1)
       @host = host
@@ -357,6 +358,100 @@ module IDRAC
           raise e
         end
       end
+    end    # 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}")
+          
+          case task_response.status
+            # 200-299
+          when 200..299
+            task = JSON.parse(task_response.body)
+
+            if task["TaskState"] != "Running"
+              break
+            end
+            
+            # 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
+            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
+          # 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"]}"
+          }
+        end
+      rescue => e
+        debugger
+        return { status: :error, error: "Exception monitoring task: #{e.message}" }
+      end
+    end
+
+    def handle_response(response)
+      # First see if there is a location header
+      if response.headers["location"]
+        return handle_location(response.headers["location"])
+      end
+
+      # If there is no location header, check the status code
+      if response.status.between?(200, 299)
+        return response.body
+      else
+        raise Error, "Failed to #{response.status} - #{response.body}"
+      end
+    end
+
+    # 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?
+      
+      # Extract the ID from the location
+      id = location.split("/").last
+      
+      # 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
+
   end
 end

data/lib/idrac/jobs.rb

@@ -28,8 +28,8 @@ module IDRAC
       if response.status == 200
         begin
           jobs_data = JSON.parse(response.body)
-          jobs_data["Members"].each do |job| 
-            puts "#{job['Id']} : #{job['JobState']} > #{job['Message']}" 
+          jobs_data["Members"].each.with_index do |job, i | 
+            puts "#{job['Id']} : #{job['JobState']} > #{job['Message']} <#{job['CompletionTime']}> [#{i+1}/#{jobs_data["Members"].count}]" 
           end
           return jobs_data
         rescue JSON::ParserError
@@ -44,6 +44,7 @@ module IDRAC
     def clear_jobs!
       # Get list of jobs
       jobs_response = authenticated_request(:get, '/redfish/v1/Managers/iDRAC.Embedded.1/Jobs?$expand=*($levels=1)')
+      handle_response(jobs_response)
       
       if jobs_response.status == 200
         begin
@@ -52,7 +53,7 @@ module IDRAC
           
           # Delete each job individually
           members.each.with_index do |job, i|
-            puts "Removing #{job['Id']} [#{i+1}/#{members.count}]"
+            puts "Removing #{job['Id']} : #{job['JobState']} > #{job['Message']} [#{i+1}/#{members.count}]".yellow
             delete_response = authenticated_request(:delete, "/redfish/v1/Managers/iDRAC.Embedded.1/Jobs/#{job['Id']}")
             
             unless delete_response.status.between?(200, 299)
@@ -89,7 +90,7 @@ module IDRAC
         # Monitor LC status until it's Ready
         puts "Waiting for LC status to be Ready..."
         
-        retries = 12  # ~2 minutes with 10s sleep
+        retries = 60  # ~10 minutes with 10s sleep
         while retries > 0
           lc_response = authenticated_request(
             :post, 
@@ -163,12 +164,15 @@ module IDRAC
             case job_state
             when "Completed"
               puts "Job completed successfully".green
+              puts "CompletionTime: #{job_data['CompletionTime']}".green if job_data['CompletionTime']
               return job_data
             when "Failed"
               puts "Job failed: #{job_data['Message']}".red
+              puts "CompletionTime: #{job_data['CompletionTime']}".red if job_data['CompletionTime'] 
               raise Error, "Job failed: #{job_data['Message']}"
             when "CompletedWithErrors"
               puts "Job completed with errors: #{job_data['Message']}".yellow
+              puts "CompletionTime: #{job_data['CompletionTime']}".yellow if job_data['CompletionTime']
               return job_data
             end