idrac 0.10.2 → 0.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e3c0e2f73e3449a852e4e46ca5838705d9ac5eeb780c7fa2023329747406a94
-  data.tar.gz: 7430d5ee6cf11aee77dd5f01990a7a1fca680cbfeb40fbad9e65a7a933ed7619
+  metadata.gz: 67737e81c936f047dc3264470e8cf3d913e10d0b300af332f4bd16aca03f4078
+  data.tar.gz: 62467838651fb0d17ab870948d1b3a82e02f5de31297a2e6d7d7ed260dea044a
 SHA512:
-  metadata.gz: 0cbb04e015b2cb0d4c5181355e34c5768250929e99b101b2a23d946b61b6b24f9b4ca8b6e803a7660ffe5f0d388d0f89c8a8b5ef9dda0cb262fcbd580260cfcc
-  data.tar.gz: e5284b739c221f9b96697dfdccb14d148e9a07ff1cc86131fc4975f608526583a13f540ba243b9167455de6325f1ced21bb6416230512f2d71a52f2765d6888b
+  metadata.gz: 4164655c54761c104a7b43f5f489972d74238c7f086b3bd865988e875eb756edaa751b6bd3241b0655c154fae57f575849d09796bbc9c0feca015192def2cbe3
+  data.tar.gz: 5aff6a5a4cbd3362e6dab402f493759ae7b0db72f75adc40c20a9cc84da2e1edea8990d27cd3b0dd4f10ee21ed0775404d101a2dd09752a8a55883dcc2312303

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

@@ -675,9 +675,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/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.3"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.3
 platform: ruby
 authors:
 - Jonathan Siegel
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -16,20 +15,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
@@ -282,7 +281,6 @@ 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
@@ -297,8 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: API Client for Dell iDRAC
 test_files: []