idrac 0.10.2 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e3c0e2f73e3449a852e4e46ca5838705d9ac5eeb780c7fa2023329747406a94
-  data.tar.gz: 7430d5ee6cf11aee77dd5f01990a7a1fca680cbfeb40fbad9e65a7a933ed7619
+  metadata.gz: 17491587256894c2ff168665dca777903a2d6b7d7582f745c4c3e81f697889cd
+  data.tar.gz: 432ecbfd6df649a69644254dc942e253a8d917f6ce2cd07c30f7f328c3ffee75
 SHA512:
-  metadata.gz: 0cbb04e015b2cb0d4c5181355e34c5768250929e99b101b2a23d946b61b6b24f9b4ca8b6e803a7660ffe5f0d388d0f89c8a8b5ef9dda0cb262fcbd580260cfcc
-  data.tar.gz: e5284b739c221f9b96697dfdccb14d148e9a07ff1cc86131fc4975f608526583a13f540ba243b9167455de6325f1ced21bb6416230512f2d71a52f2765d6888b
+  metadata.gz: 28cc04b7ec2f246ed29d95ba50481f52dff7893e69fd94dc6f82db81e0d7b988e6d0e21589ae09a75e99c51621f2a6650a1aa0ada2c74c8aa4ff6f2726cadf98
+  data.tar.gz: 6981e38fe25c803372a0c09aa3616db6ce7d0670415fbec9f73e143c25e44fff25e24ea650dfe5ebfcc821b14c6d17dd778664e43d11b5fbfd8c6458cacae374

data/README.md

@@ -167,9 +167,14 @@ client.clear_jobs!
 # Force clear job queue (use with caution)
 client.force_clear_jobs!
 
-# Wait for a specific job to complete
+# Wait for a specific job to complete (raises IDRAC::Error if the job failed)
 job_data = client.wait_for_job("JID_12345678")
 
+# Wait for a job and get its outcome back instead of an exception
+result = client.wait_for_job_completion("JID_12345678")
+# => { status: :success, job_id: "JID_12345678", job_state: "Completed",
+#      message: "...", messages: ["..."], job: { ... } }
+
 # Lifecycle Controller operations
 # Check if Lifecycle Controller is enabled
 status = client.get_idrac_lifecycle_status
@@ -291,6 +296,30 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Changelog
 
+### Version 0.10.3
+- **Fixed: SCP imports reported as failures when they had succeeded**: `set_system_configuration_profile` waited on the *task* that submitted the import. iDRAC answers the import with a TaskService URI whose id is the id of the job it queued, and that task sits at `TaskState "Pending"` / `"New job."` while the job does the real work. The transient task state was returned as `{status: :failed, task_state: "Pending", messages: ["New job."]}`, so callers aborted on imports that went on to complete.
+  - The import now waits for the **job** to reach a terminal state and returns the **job's** outcome
+  - Return value: `{ status: :success | :failed | :timeout, job_id:, job_state:, message:, messages:, job: }`, plus `error:` for anything other than `:success` (`:status` is unchanged; `:job_id` is new, so callers no longer have to diff the job list to find the job)
+  - `Failed`, `CompletedWithErrors`, and `RebootFailed` surface the job's own `Message`
+  - A location header that points straight at a job still uses the job path
+  - New `timeout:` option (default 600s)
+- **New `wait_for_job_completion(job_id, timeout:, interval:)`**: waits for a job and returns its outcome as a hash rather than raising, keeps polling while the host is briefly unreachable (an SCP import can bounce it), and always reports the job id
+- **Fixed `wait_for_task` treating a queued task as failed**: it broke out of its poll loop on any state other than `Running`, so `New`/`Pending`/`Starting` were reported as failures. It now waits through every non-terminal state, accepts a full location header, and takes a `timeout:` (default 600s)
+- **Removed stray `debugger` calls** from `wait_for_task` and `import_system_configuration`
+
+### Version 0.10.2
+- **Fixed: firmware updates matched the wrong Dell Update Package**: `check_updates` paired an installed component with a catalog DUP by display name. Names are ambiguous — every NIC package reads "Ethernet" — so it selected packages that do not flash the installed device. iDRAC rejected those on apply (RED097 / "not compatible") and the version column compared unrelated components.
+  - Matching is now done on the Dell **componentID**, the key that actually identifies the device
+  - `find_updates_for_system` records `component_ids:` for each DUP, read from `SupportedDevices/Device/@componentID`
+  - `get_system_inventory` records `component_id:` for each installed component, from the Dell OEM block when present and otherwise parsed out of the inventory `Id` (`Installed-<componentID>-<version>`), which is all iDRAC8 exposes
+  - New `FirmwareCatalog#updates_for_component(catalog_updates, fw)` does the matching, and falls back to the old name heuristic only when the inventory reports no componentID (or reports `"0"`)
+  - New `FirmwareCatalog#version_key(version)` gives a sortable key, so when the catalog lists several revisions for one component the newest is chosen
+- **Fixed: every component reported as out of date**: the catalog version came from `dellVersion`, which is the package revision label (`A17`), not a version. Comparing that against an installed numeric version (`25.5.9.0001`) flagged everything. `vendorVersion` is now preferred.
+
+### Versions 0.10.0-0.10.1
+- Use the Dell OEM `Install` action on iDRAC8 instead of `SimpleUpdate`
+- Fixed a false-positive virtual-media "inserted" state on iDRAC8 (benign VRM0009 500 on eject is now a no-op)
+
 ### Version 0.9.1
 - **Code Simplification**: Removed redundant `handle_response` calls throughout the codebase
   - `authenticated_request` now automatically handles error responses (status >= 400)

data/bin/idrac

@@ -1663,12 +1663,19 @@ module IDRAC
     # TSR (Technical Support Report) commands
     desc "tsr_collect", "Generate and download TSR/SupportAssist collection"
     method_option :output, type: :string, desc: "Output filename"
+    method_option :timeout, type: :numeric, default: 600, desc: "Seconds to wait for collection to complete"
+    method_option :data_types, type: :string, desc: "Comma-separated log types to collect (0=HWData, 1=OSAppData, 2=TTYLogs, 3=DebugLogs; default: HWData,OSAppData)"
     def tsr_collect
       with_idrac_client do |client|
         puts "Generating and downloading TSR logs...".yellow
         puts "This may take several minutes...".yellow
-        
-        result = client.generate_and_download_tsr(output_file: options[:output])
+
+        data_selector = options[:data_types]&.split(',')
+        result = client.generate_and_download_tsr(
+          output_file: options[:output],
+          data_selector_values: data_selector,
+          wait_timeout: options[:timeout]
+        )
         
         if result
           puts "TSR logs saved to: #{result}".green

data/idrac.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Dependencies - Using semantic versioning recommendations
-  spec.add_dependency "httparty", "~> 0.21", ">= 0.21.0"
+  spec.add_dependency "httparty", "~> 0.24", ">= 0.24.0"
   spec.add_dependency "nokogiri", "~> 1.15", ">= 1.15.0"
   spec.add_dependency "faraday", "~> 2.7", ">= 2.7.0"
   spec.add_dependency "faraday-multipart", "~> 1.0", ">= 1.0.0"

data/lib/idrac/boot.rb

@@ -323,22 +323,7 @@ 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
@@ -675,9 +660,8 @@ module IDRAC
         body: params.to_json
       )
       
-      task = wait_for_task(response.headers["location"])
-      debugger
-      return task
+      # Same operation as set_system_configuration_profile: wait on the import JOB.
+      return wait_for_scp_import(response.headers["location"])
     end
   end
 end 

data/lib/idrac/client.rb

@@ -392,10 +392,18 @@ module IDRAC
           raise e
         end
       end
-    end    # Wait for a task to complete
+    end
+
+    # Task states that mean the task has not produced a result yet. A task that has only
+    # been queued reports "Pending"/"New" ("New job."), which is not an outcome -- so we
+    # keep waiting instead of reporting that transient state as a failure.
+    TASK_INCOMPLETE_STATES = %w[New Starting Pending Running Stopping Cancelling].freeze
 
-    def wait_for_task(task_id)
+    # Wait for a task to complete
+    def wait_for_task(task_id, timeout: 600)
+      task_id = task_id.to_s.split("/").last # tolerate being handed a full location header
       task = nil
+      deadline = Time.now + timeout
       
       begin
         loop do
@@ -406,9 +414,7 @@ module IDRAC
           when 200..299
             task = JSON.parse(task_response.body)
 
-            if task["TaskState"] != "Running"
-              break
-            end
+            break unless TASK_INCOMPLETE_STATES.include?(task["TaskState"])
             
             # Extract percentage complete if available
             percent_complete = nil
@@ -418,6 +424,12 @@ module IDRAC
             end
             
             debug "Waiting for task to complete...: #{task["TaskState"]} #{task["TaskStatus"]}", 1
+            
+            if Time.now >= deadline
+              return { status: :timeout, task_state: task["TaskState"], task_status: task["TaskStatus"],
+                       error: "Timed out after #{timeout}s waiting for task #{task_id} (state: #{task["TaskState"]})" }
+            end
+            
             sleep 5
           else
             return { 
@@ -451,7 +463,7 @@ module IDRAC
           }
         end
       rescue => e
-        debugger
+        debug "Exception monitoring task #{task_id}: #{e.message}", 1, :red
         return { status: :error, error: "Exception monitoring task: #{e.message}" }
       end
     end

data/lib/idrac/jobs.rb

@@ -185,7 +185,55 @@ module IDRAC
       
       raise Error, "Timeout waiting for job to complete"
     end
-    
+
+    # Job states that mean the job is finished, one way or another.
+    JOB_TERMINAL_STATES = %w[Completed CompletedWithErrors Failed RebootFailed].freeze
+
+    # Wait for an iDRAC job to reach a terminal state and report on the JOB itself.
+    #
+    # Unlike wait_for_job this does not raise for a job that simply failed -- it returns
+    # the outcome so the caller can log or re-check it. The hash always carries :job_id.
+    #
+    #   { status: :success | :failed | :timeout, job_id:, job_state:,
+    #     message:, messages: [message], job: <raw job data>,
+    #     error: <the job's own message, on anything but :success> }
+    def wait_for_job_completion(job_id, timeout: 600, interval: 10)
+      job_id = job_id.to_s.split("/").last
+      deadline = Time.now + timeout
+      state = nil
+      last_error = nil
+
+      while Time.now < deadline
+        begin
+          response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/Jobs/#{job_id}")
+          job = response.status == 200 ? JSON.parse(response.body) : nil
+          state = job ? job["JobState"] : nil
+
+          if JOB_TERMINAL_STATES.include?(state)
+            message = job["Message"] || Array(job["Messages"]).map { |m| m["Message"] }.compact.first
+            success = state == "Completed"
+            debug "Job #{job_id} #{state}: #{message}", 1, success ? :green : :red
+            result = { status: success ? :success : :failed, job_id: job_id, job_state: state,
+                       message: message, messages: [message].compact, job: job }
+            result[:error] = message || "Job #{job_id} finished with state #{state}" unless success
+            return result
+          end
+
+          last_error = "HTTP #{response.status}" unless job
+          debug "Job #{job_id} state: #{state || last_error}. Waiting...", 1, :yellow
+        rescue StandardError => e
+          # An SCP import can bounce the host, so a job can be briefly unreadable. Keep polling.
+          last_error = e.message
+          debug "Job #{job_id} not readable (#{e.message}). Waiting...", 1, :yellow
+        end
+
+        sleep interval
+      end
+
+      { status: :timeout, job_id: job_id, job_state: state,
+        error: "Timed out after #{timeout}s waiting for job #{job_id} (last state: #{state || last_error || 'unknown'})" }
+    end
+
     # Get system tasks
     def tasks
       response = authenticated_request(:get, '/redfish/v1/TaskService/Tasks')

data/lib/idrac/power.rb

@@ -58,7 +58,15 @@ module IDRAC
       return true
     end
     
+    # Reset types that restart the host rather than leave it down. A restart never settles on
+    # "Off", so it must never be waited on — or escalated to — as if it were a shutdown.
+    RESTART_TYPES = %w[ForceRestart GracefulRestart PowerCycle].freeze
+
     def power_off(wait: true, kind: "ForceOff")
+      # A restart is not a shutdown. Sent down the power-off path it fails the wait for "Off" and
+      # escalates to ForceOff, which leaves the host powered down. Route it to the restart instead.
+      return reboot(kind: kind, wait: wait) if RESTART_TYPES.include?(kind)
+
       ensure_authenticated!
       
       puts "Powering off server...".light_cyan
@@ -93,37 +101,39 @@ module IDRAC
       return true
     end
     
-    def reboot
+    def reboot(kind: "ForceRestart", wait: false)
       ensure_authenticated!
       
-      puts "Rebooting server...".light_cyan
+      puts "Rebooting server (#{kind})...".light_cyan
 
       # Check current power state first
       current_state = get_power_state rescue "Unknown"
       if current_state == "Off"
         puts "Server is currently off, powering on instead of rebooting".yellow
-        return power_on
+        return power_on(wait: wait)
       end
       
-      # Send reboot command (Reset with ResetType=ForceRestart)
       path = "/redfish/v1/Systems/System.Embedded.1/Actions/ComputerSystem.Reset"
-      payload = { "ResetType" => "ForceRestart" }
-      
-      response = authenticated_request(:post, path, body: payload.to_json)
+      response = authenticated_request(:post, path, body: { "ResetType" => kind }.to_json)
       
       if response.status >= 200 && response.status < 300
         puts "Server reboot command sent successfully".green
-        return true
-      elsif response.status == 409
+      elsif response.status == 409 && kind != "GracefulRestart"
         error_data = JSON.parse(response.body) rescue nil
         puts "Received conflict (409) error from iDRAC: #{error_data.inspect}"
         # Try gracefulRestart as an alternative
         puts "Trying GracefulRestart instead...".yellow
-        payload = { "ResetType" => "GracefulRestart" }
-        authenticated_request(:post, path, body: payload.to_json)
+        response = authenticated_request(:post, path, body: { "ResetType" => "GracefulRestart" }.to_json)
+        raise Error, "Failed to reboot server. Status code: #{response.status}" unless response.status.between?(200, 299)
       else
         raise Error, "Failed to reboot server. Status code: #{response.status}"
       end
+      
+      # "On" is the only terminal state a restart reaches. Never wait for "Off" here: the host may
+      # never report it, and treating that as failure is what turned a reboot into a shutdown.
+      wait_for_power_state(target_state: "On", tries: 12) if wait
+      
+      return true
     end
     
     def get_power_state

data/lib/idrac/system_config.rb

@@ -84,8 +84,13 @@ module IDRAC
       end
     end
 
-    # Apply a system configuration profile to the iDRAC
-    def set_system_configuration_profile(scp, target: "ALL", reboot: false, retry_count: 0)
+    # Apply a system configuration profile to the iDRAC.
+    #
+    # Waits for the import JOB to finish and returns the JOB's outcome:
+    #
+    #   { 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)
       # Ensure scp has the proper structure with SystemConfiguration wrapper
       scp_to_apply = if scp.is_a?(Hash) && scp["SystemConfiguration"]
         scp
@@ -135,7 +140,27 @@ module IDRAC
         return { status: :failed, error: error_message }
       end
       
-      return handle_location(response.headers["location"])
+      return wait_for_scp_import(response.headers["location"], timeout: timeout)
+    end
+
+    # Wait for an SCP import submitted at +location+ and report the JOB's outcome.
+    #
+    # iDRAC answers the import with a TaskService URI whose id is the id of the job it
+    # queued (/redfish/v1/TaskService/Tasks/JID_...). That task is only the submission:
+    # it sits at TaskState "Pending" / "New job." while the job does the real work, so
+    # waiting on the task reports a queued job as a failure. The job is the operation,
+    # so the job is what we wait on -- and the job id goes back to the caller.
+    def wait_for_scp_import(location, timeout: 600)
+      return { status: :failed, error: "SCP import returned no location header" } if location.nil? || location.to_s.empty?
+
+      id = location.to_s.split("/").last
+      # Dell job ids (JID_/RID_) name the job whether the header points at the job itself
+      # or at the task that queued it. Anything else is a real task: handle it as before.
+      if location.to_s.include?("/Jobs/") || id.start_with?("JID_", "RID_")
+        wait_for_job_completion(id, timeout: timeout)
+      else
+        handle_location(location)
+      end
     end
 
     # This puts the SCP into a format that can be used by reasonable Ruby code.

data/lib/idrac/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.4
 platform: ruby
 authors:
 - Jonathan Siegel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-03 00:00:00.000000000 Z
+date: 2026-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '0.24'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.24.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '0.24'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.24.0
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement