idrac 0.10.6 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fae473e8260d010235ebf86c7ed40b33dae6b7a1c14c2576bce55fecc319c7be
-  data.tar.gz: 8c115aeb8c6399d2d3d167204b160ef691b64ec41570b371912df697b23d9789
+  metadata.gz: aae19c4ce800e57cb1b15ca37be3d48d1c22f52d2eb455a877fe517f21bd65f4
+  data.tar.gz: 1f772c3a6c316578e572e8b797695e19096e1a04e424f38633f6dfad56b6a12c
 SHA512:
-  metadata.gz: 278b81e8955021924c44c496b0df20c34f59e3630f9df3decda96ee519cadc0445901cddbf3c78c174313c36eef558780ce444fb09f3d870039adc23e7da5056
-  data.tar.gz: c66f192778e2e32cf724b3b98ef45c2311a79ee8f0144e0f95a3106ff1d2d87f67f13c30eac4a47c2055e302bb5b2dc373cf37cfc760ff2566a8f949531db061
+  metadata.gz: 51c2314dee2b317013816c1e87aacd0d2f5808bb63921826da788d50248e7b84fb871b14abcbc92f92b56ae7cea18d69b5ed32727939549351ee8026510356a1
+  data.tar.gz: e2fe2aad75892982b41819ac1dafd13a7317c85e7d427ee6379b21a8b2daa1e2563c87b1ac97d1910ff9f5900058562a727b06b3e104e9a3183cb82850843db0

data/lib/idrac/boot.rb

@@ -140,7 +140,8 @@ module IDRAC
     end
     
     # Set boot override for next boot
-    def set_boot_override(target, enabled: "Once", mode: nil)
+    def set_boot_override(target, persistence: nil, mode: nil)
+      persistence = "Once" unless persistence
       # Validate target against allowed values
       boot_data = boot
       valid_targets = boot_data["allowed_override_targets"]
@@ -150,11 +151,11 @@ module IDRAC
         raise Error, "Invalid boot target: #{target}"
       end
       
-      debug "Setting boot override to #{target} (#{enabled})...", 1, :yellow
+      debug "Setting boot override to #{target} (#{persistence})...", 1, :yellow
       
       body = {
         "Boot" => {
-          "BootSourceOverrideEnabled" => enabled,  # Disabled/Once/Continuous
+          "BootSourceOverrideEnabled" => persistence,  # Disabled/Once/Continuous
           "BootSourceOverrideTarget" => target     # None/Pxe/Hdd/Cd/etc
         }
       }
@@ -225,24 +226,24 @@ module IDRAC
     end
     
     # Convenience methods for common boot targets
-    def boot_to_pxe(enabled: "Once", mode: nil)
-      set_boot_override("Pxe", enabled: enabled, mode: mode)
+    def boot_to_pxe(persistence: nil, mode: nil)
+      set_boot_override("Pxe", persistence: persistence, mode: mode)
     end
     
-    def boot_to_disk(enabled: "Once", mode: nil)
-      set_boot_override("Hdd", enabled: enabled, mode: mode)
+    def boot_to_disk(persistence: nil, mode: nil)
+      set_boot_override("Hdd", persistence: persistence, mode: mode)
     end
     
-    def boot_to_cd(enabled: "Once", mode: nil)
-      set_boot_override("Cd", enabled: enabled, mode: mode)
+    def boot_to_cd(persistence: nil, mode: nil)
+      set_boot_override("Cd", persistence: persistence, mode: mode)
     end
     
-    def boot_to_usb(enabled: "Once", mode: nil)
-      set_boot_override("Usb", enabled: enabled, mode: mode)
+    def boot_to_usb(persistence: nil, mode: nil)
+      set_boot_override("Usb", persistence: persistence, mode: mode)
     end
     
-    def boot_to_bios_setup(enabled: "Once", mode: nil)
-      set_boot_override("BiosSetup", enabled: enabled, mode: mode)
+    def boot_to_bios_setup(persistence: nil, mode: nil)
+      set_boot_override("BiosSetup", persistence: persistence, mode: mode)
     end
     
     private
@@ -663,5 +664,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/firmware.rb

@@ -590,11 +590,10 @@ module IDRAC
         end
         
         # Construct the firmware URI from the upload response
-        image_uri = if firmware_id
-          "#{http_push_uri}/#{firmware_id}"
-        else
-          upload_response.headers['Location'] || http_push_uri
-        end
+        # Prefer @odata.id from response body, then Location header, then constructed path
+        image_uri = upload_data&.dig('@odata.id') ||
+                    upload_response.headers['Location'] ||
+                    (firmware_id ? "#{http_push_uri}/#{firmware_id}" : http_push_uri)
 
         # Check if Dell OEM Install action is available (iDRAC8)
         # This is more reliable than SimpleUpdate on older iDRACs
@@ -604,9 +603,10 @@ module IDRAC
         if dell_install_target
           puts "Using Dell OEM Install action (iDRAC8)...".light_cyan
           puts "Firmware URI: #{image_uri}".light_cyan
+          # iDRAC8 DellUpdateService.Install expects @odata.id URIs
           install_payload = {
             "SoftwareIdentityURIs" => [image_uri],
-            "InstallUpon" => "Now"
+            "InstallUpon" => "NowAndReboot"
           }
           update_response = client.authenticated_request(
             :post,

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.11.0"
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.10.6
+  version: 0.11.0
 platform: ruby
 authors:
 - Jonathan Siegel
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -281,6 +282,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/buildio/idrac
   source_code_uri: https://github.com/buildio/idrac
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -295,7 +297,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: API Client for Dell iDRAC
 test_files: []