idrac 0.10.6 → 0.10.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fae473e8260d010235ebf86c7ed40b33dae6b7a1c14c2576bce55fecc319c7be
-  data.tar.gz: 8c115aeb8c6399d2d3d167204b160ef691b64ec41570b371912df697b23d9789
+  metadata.gz: bfa684ed67c2db2f200633f5db13d173a30f49c67b07b05da83844708bdacfa4
+  data.tar.gz: 1308339f369f5d9ec0c028f64effac7d43e39cc93dcfad88e2d5d88a6b954f53
 SHA512:
-  metadata.gz: 278b81e8955021924c44c496b0df20c34f59e3630f9df3decda96ee519cadc0445901cddbf3c78c174313c36eef558780ce444fb09f3d870039adc23e7da5056
-  data.tar.gz: c66f192778e2e32cf724b3b98ef45c2311a79ee8f0144e0f95a3106ff1d2d87f67f13c30eac4a47c2055e302bb5b2dc373cf37cfc760ff2566a8f949531db061
+  metadata.gz: abc37992c28ab713b5960b51144bcda9f3d80ed197e7a35284c5509392f82b258072bfce2b3a3b1c3d30956b2996459b42a18582de2896d61a1e3df6851a2946
+  data.tar.gz: 65219a49a799565089f2bb59722314ba3433a2c5dc17c035d92a2bf0d6a1712b4c964f0489fa0d1a5935a65390ed9d1fbd4c99a7832d055b11730739d5068f6a

data/lib/idrac/boot.rb

@@ -663,5 +663,114 @@ module IDRAC
       # Same operation as set_system_configuration_profile: wait on the import JOB.
       return wait_for_scp_import(response.headers["location"])
     end
+
+    ########################################################
+    # Boot mechanics moved out of the app's raw Redfish (radfish #40). These used to live in the
+    # app's Infra::OsInstall as hand-rolled authenticated_request calls; the iDRAC BootSources /
+    # one-time-boot mechanics belong here, the adapter and the radfish facade just expose them.
+    ########################################################
+
+    # Stale UEFI boot placeholders a prior OS can leave behind. Dell names them
+    # "Unknown.Unknown.<n>-<n>"; left ENABLED they make UEFI loop over dead entries and can keep a
+    # node from ever reaching an install (this trapped n008: PXE plus five "Unknown.Unknown" ghosts,
+    # no disk entry). The default match targets exactly them.
+    STALE_UEFI_BOOT_ENTRY = /\AUnknown\.Unknown\./
+
+    # The still-ENABLED UEFI boot entries whose Name matches +match+ (default: the stale
+    # "Unknown.Unknown.*" placeholders). Returns the raw BootSources entry hashes so callers can read
+    # Name/Id/Index; [] when there are none. Read-only.
+    def stale_uefi_boot_entries(match: STALE_UEFI_BOOT_ENTRY)
+      res = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/BootSources")
+      body = res.body.is_a?(String) ? JSON.parse(res.body) : res.body
+      seq = body.dig("Attributes", "UefiBootSeq") || []
+      seq.select { |e| e["Name"].to_s.match?(match) && e["Enabled"] != false }
+    end
+
+    # Disable the UEFI boot entries whose Name matches +match+ (default: the stale
+    # "Unknown.Unknown.*" placeholders) and return the NAMES disabled ([] when there was nothing to
+    # do). Drains any pending Lifecycle Controller config job FIRST so scheduling ours never trips
+    # LC068, then PATCHes BootSources/Settings and POSTs the BIOS config job that applies the change.
+    # The disable is applied by a reboot -- the LifecycleController runs the pending job during POST
+    # -- so by default this only SCHEDULES it and the caller owns power. Pass wait: true to poll the
+    # scheduled BIOS config job to a terminal state here (via wait_config_job) before returning.
+    def disable_boot_entries(match: STALE_UEFI_BOOT_ENTRY, wait: false, timeout: 900)
+      res = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/BootSources")
+      body = res.body.is_a?(String) ? JSON.parse(res.body) : res.body
+      seq = body.dig("Attributes", "UefiBootSeq") || []
+      stale = seq.select { |e| e["Name"].to_s.match?(match) && e["Enabled"] != false }
+      return [] if stale.empty?
+
+      # A stale pending job would make the config-job POST below hard-fail with LC068; drain first.
+      drain_pending_config_jobs!
+
+      newseq = seq.each_with_index.map do |e, i|
+        off = e["Name"].to_s.match?(match)
+        { "Enabled" => (off ? false : e["Enabled"]), "Id" => e["Id"], "Index" => i, "Name" => e["Name"] }
+      end
+      patch = authenticated_request(:patch, "/redfish/v1/Systems/System.Embedded.1/BootSources/Settings",
+                                    body: JSON.generate("Attributes" => { "UefiBootSeq" => newseq }))
+      raise Error, "Disabling stale boot sources failed (HTTP #{patch.status}): #{patch.body}" unless patch.status.between?(200, 299)
+
+      job = authenticated_request(:post, "/redfish/v1/Managers/iDRAC.Embedded.1/Jobs",
+                                  body: JSON.generate("TargetSettingsURI" => "/redfish/v1/Systems/System.Embedded.1/BootSources/Settings"))
+      raise Error, "BIOS config job for boot sources failed (HTTP #{job.status}): #{job.body}" unless job.status.between?(200, 299)
+
+      # Default: the caller's reboot applies the change (LC runs the pending job during POST). With
+      # wait: true, poll the scheduled config job to a terminal state -- reuse Jobs#wait_config_job.
+      if wait
+        headers = job.respond_to?(:headers) ? (job.headers || {}) : {}
+        jid = (headers["location"] || headers["Location"]).to_s[/(JID_\w+)/, 1] || job.body.to_s[/(JID_\w+)/, 1]
+        wait_config_job(jid, timeout: timeout) if jid
+      end
+
+      names = stale.map { |e| e["Name"] }
+      puts "Disabled #{names.size} stale UEFI boot #{names.size == 1 ? 'entry' : 'entries'} " \
+           "(#{names.join(', ')}); a BIOS config job applies it at the next boot.".green
+      names
+    end
+
+    # Redfish BootProgress.LastState mapped to the snake_case symbols radfish orders boots by
+    # (Radfish::Client::BOOT_PROGRESS_ORDER). Explicit so the acronym cases (PCI, OS) normalize
+    # correctly instead of through a naive underscore.
+    BOOT_PROGRESS_STATES = {
+      "None" => :none,
+      "PrimaryProcessorInitializationStarted" => :primary_processor_initialization_started,
+      "BusInitializationStarted" => :bus_initialization_started,
+      "MemoryInitializationStarted" => :memory_initialization_started,
+      "SecondaryProcessorInitializationStarted" => :secondary_processor_initialization_started,
+      "PCIResourceConfigStarted" => :pci_resource_config_started,
+      "SystemHardwareInitializationComplete" => :system_hardware_initialization_complete,
+      "SetupEntered" => :setup_entered,
+      "OSBootStarted" => :os_boot_started,
+      "OSRunning" => :os_running
+    }.freeze
+
+    # Normalized last BootProgress state (a snake_case Symbol from BOOT_PROGRESS_STATES), or nil when
+    # the BMC does not report BootProgress at all (iDRAC8 omits it). nil means "cannot observe", never
+    # "not running" -- callers fall back to other signals.
+    def boot_progress
+      res = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1?$select=BootProgress")
+      body = res.body.is_a?(String) ? JSON.parse(res.body) : res.body
+      last = body.is_a?(Hash) ? body.dig("BootProgress", "LastState") : nil
+      return nil if last.nil? || last.to_s.empty?
+      BOOT_PROGRESS_STATES[last] || last.to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+    end
+
+    # Dell one-time boot to the virtual CD via an SCP import (the reliable path on this fleet). Drains
+    # any pending Lifecycle Controller config job first (a stale one makes the import hard-fail with
+    # LC068 "a configuration job is already scheduled"), then imports ServerBoot.1#BootOnce +
+    # FirstBootDevice=VCD-DVD. BootOnce makes the BIOS fall back to the standing order after one boot,
+    # so no boot-order reorder is needed here. Raises on a failed import; returns the import result hash.
+    def set_one_time_cd_boot(reboot: false)
+      drain_pending_config_jobs!
+      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" } ] }
+      res = set_system_configuration_profile(scp, target: "ALL", reboot: reboot)
+      unless res.is_a?(Hash) && res[:status] == :success
+        raise Error, "SCP one-time vCD boot failed: #{res[:job_state]} #{res[:error] || res[:message]} (job #{res[:job_id]})"
+      end
+      res
+    end
   end
-end 
+end

data/lib/idrac/jobs.rb

@@ -234,6 +234,56 @@ module IDRAC
         error: "Timed out after #{timeout}s waiting for job #{job_id} (last state: #{state || last_error || 'unknown'})" }
     end
 
+    # Delete every Lifecycle Controller config job that is NOT Completed, and return the ids drained
+    # ([] when there was nothing to drain). The iDRAC serializes LC config jobs: one left
+    # Scheduled/Running/New/Pending makes the NEXT SCP import or config-job POST hard-fail with LC068
+    # ("a configuration job is already scheduled"). Repeated install/break-glass runs leave exactly
+    # such a stale job behind (this wedged n000), so anything that schedules its own config job drains
+    # first. Completed jobs are harmless and are kept. Best-effort: a failed queue read/delete is
+    # logged and swallowed (returns []), and the later schedule surfaces LC068 the old way rather than
+    # this raising. Moved out of the app's raw Redfish (radfish #40).
+    def drain_pending_config_jobs!
+      resp = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/Jobs?$expand=*($levels=1)")
+      return [] unless resp.status.to_i == 200
+      pending = (JSON.parse(resp.body)["Members"] || []).reject { |j| j["JobState"].to_s == "Completed" }
+      return [] if pending.empty?
+      puts "Draining #{pending.size} pending config job(s) that would block a new one (LC068): " \
+           "#{pending.map { |j| "#{j['Id']}=#{j['JobState']}" }.join(', ')}".yellow
+      pending.each { |j| authenticated_request(:delete, "/redfish/v1/Managers/iDRAC.Embedded.1/Jobs/#{j['Id']}") }
+      pending.map { |j| j["Id"] }
+    rescue StandardError => e
+      puts "Could not drain pending config jobs (#{e.class}: #{e.message.lines.first.to_s.strip}); proceeding.".yellow
+      []
+    end
+
+    # Job states that mean a BIOS/config job has finished, one way or another.
+    CONFIG_JOB_TERMINAL_STATES = %w[Completed Failed CompletedWithErrors].freeze
+
+    # Poll a Lifecycle Controller job (e.g. the BIOS config job that a BootSources change schedules)
+    # until it reaches a terminal state, and RETURN that state string. Returns nil on timeout rather
+    # than raising -- the caller proceeds without confirmation (a still-pending job costs a slower
+    # boot, not a wrong one). A transient read error is treated as "keep polling". Moved out of the
+    # app's raw Redfish (radfish #40).
+    def wait_config_job(jid, timeout: 900, interval: 20)
+      deadline = Time.now + timeout
+      loop do
+        state = begin
+          res = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/Jobs/#{jid}")
+          body = res.body.is_a?(String) ? JSON.parse(res.body) : res.body
+          body.is_a?(Hash) ? body["JobState"] : nil
+        rescue StandardError
+          nil
+        end
+        return state if CONFIG_JOB_TERMINAL_STATES.include?(state)
+        if Time.now > deadline
+          puts "Config job #{jid} did not finish within #{timeout}s (last state #{state.inspect}); " \
+               "proceeding without confirmation.".yellow
+          return nil
+        end
+        sleep interval
+      end
+    end
+
     # Get system tasks
     def tasks
       response = authenticated_request(:get, '/redfish/v1/TaskService/Tasks')

data/lib/idrac/system_config.rb

@@ -90,7 +90,13 @@ module IDRAC
     #
     #   { status: :success | :failed | :timeout, job_id:, job_state:, message:,
     #     messages: [message], job: <raw job data>, error: <message unless :success> }
-    def set_system_configuration_profile(scp, target: "ALL", reboot: false, timeout: 600, retry_count: 0)
+    def set_system_configuration_profile(scp, target: "ALL", reboot: false, timeout: 600, retry_count: 0, drain: true)
+      # A stale Lifecycle Controller job left pending/scheduled makes this import hard-fail with
+      # RED/LC068 ("a configuration job is already scheduled"). Anticipate it: drain any still-
+      # incomplete config job first (self-heal, don't hard-fail) so the import goes through. Pass
+      # drain: false to keep an in-flight job (e.g. when a long-running job must not be disturbed).
+      drain_pending_config_jobs! if drain
+
       # Ensure scp has the proper structure with SystemConfiguration wrapper
       scp_to_apply = if scp.is_a?(Hash) && scp["SystemConfiguration"]
         scp

data/lib/idrac/version.rb

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

metadata

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