idrac 0.8.6 → 0.8.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac429e71f14867043a891ec594d159e49210c4662f6c8993273423fc47470aea
-  data.tar.gz: e12a69a35a3846944b7868a301c9d59210afd855f8fd6a7ab59bb4a2f7f07140
+  metadata.gz: 23b4d692e6a2623cda4369dafdc0e88755cf8e1eef198c83f85df88d670731ca
+  data.tar.gz: 9604b4d3dbc0277f9ffd7e1cf1029ece1517cb6a3868bc03dbc79d6abaccd74e
 SHA512:
-  metadata.gz: 26d106fec37924d587fbcc774e3d81a0a9a464b10fd68b831df60e08fcbcbfa8bec012e216cfa5ef13732f9198d5a2d64f6ac6c01393d6b088cd6d4d3ebc6eb8
-  data.tar.gz: 1144098c052f5d7939ff0fbcda31273e5287718a27803fd597f5decc4a90a9a0aa909ad9857f70b77063bfece56716734acf970afa8cefca7c20adb73ead2558
+  metadata.gz: 3646343bd2da2105448b15160f96c358e2971996daff9b1659ec4686f7f4cb259d76bf741205804c081e8b58e97b4060b0f2470bb9729bca5e480cdb37ad430e
+  data.tar.gz: d784e26447e27b12b87e873f9780dae75fd85ac895927b786b84c51e8b332d6215a357636b7e66b1524abfbef941192d8ef3d27a09b1fb3937113d21c7e22e23

data/lib/idrac/boot.rb

@@ -555,9 +555,12 @@ module IDRAC
         begin
           data = JSON.parse(response.body)
           if data["Attributes"] && data["Attributes"].has_key?("ErrPrompt")
-            return data["Attributes"]["ErrPrompt"] == "Disabled"
+            current_value = data["Attributes"]["ErrPrompt"]
+            debug "ErrPrompt current value: '#{current_value}' (checking if == 'Disabled')", 1, :cyan
+            return current_value == "Disabled"
           else
             debug "ErrPrompt attribute not found in BIOS settings", 1, :yellow
+            debug "Available BIOS attributes: #{data['Attributes']&.keys&.sort&.join(', ')}", 2, :yellow if data["Attributes"]
             return false
           end
         rescue JSON::ParserError
@@ -640,18 +643,18 @@ module IDRAC
       
       settings.each do |key, value|
         attributes << {
-          "Name": key.to_s,
-          "Value": value,
-          "Set On Import": "True"
+          "Name" => key.to_s,
+          "Value" => value,
+          "Set On Import" => "True"
         }
       end
       
       scp = {
-        "SystemConfiguration": {
-          "Components": [
+        "SystemConfiguration" => {
+          "Components" => [
             {
-              "FQDD": "BIOS.Setup.1-1",
-              "Attributes": attributes
+              "FQDD" => "BIOS.Setup.1-1",
+              "Attributes" => attributes
             }
           ]
         }
@@ -663,9 +666,9 @@ module IDRAC
     # Import System Configuration Profile for advanced configurations
     def import_system_configuration(scp, target: "ALL", reboot: false)
       params = {
-        "ImportBuffer": JSON.pretty_generate(scp),
-        "ShareParameters": {
-          "Target": target
+        "ImportBuffer" => JSON.generate(scp),
+        "ShareParameters" => {
+          "Target" => target
         }
       }
       # Configure shutdown behavior

data/lib/idrac/client.rb

@@ -193,6 +193,12 @@ module IDRAC
       original_timeout = conn.options.timeout
       original_open_timeout = conn.options.open_timeout
       
+      # Add host header if specified (needed for SSH tunnels to iDRAC)
+      if @host_header
+        headers = headers.merge('Host' => @host_header)
+        debug "Added Host header to iDRAC request: #{@host_header}", 2
+      end
+      
       begin
         conn.options.timeout = timeout if timeout
         conn.options.open_timeout = open_timeout if open_timeout
@@ -360,6 +366,17 @@ module IDRAC
       retries = 0
       begin
         yield
+      rescue ServiceTemporarilyUnavailableError => e
+        retries += 1
+        if retries <= max_retries
+          delay = e.retry_delay  # Use the delay specified by iDRAC
+          debug "🕒 IDRAC REQUESTED RETRY: ServiceTemporarilyUnavailable - Attempt #{retries}/#{max_retries}, waiting #{delay}s as instructed by iDRAC", 1, :cyan
+          sleep delay
+          retry
+        else
+          debug "MAX RETRIES REACHED: #{e.message} after #{max_retries} attempts", 1, :red
+          raise e
+        end
       rescue *error_classes => e
         retries += 1
         if retries <= max_retries
@@ -446,7 +463,54 @@ module IDRAC
       if response.status.between?(200, 299)
         return response.body
       else
-        raise Error, "Failed to #{response.status} - #{response.body}"
+        # Enhanced error handling with ExtendedInfo support
+        error_message = "Failed with status #{response.status}"
+        
+        begin
+          error_data = JSON.parse(response.body)
+          
+          # Check for standard error message
+          if error_data['error'] && error_data['error']['message']
+            error_message += ": #{error_data['error']['message']}"
+          end
+          
+          # Check for ExtendedInfo which contains detailed error information
+          if error_data['error'] && error_data['error']['@Message.ExtendedInfo']
+            extended_info = error_data['error']['@Message.ExtendedInfo']
+            if extended_info.is_a?(Array) && extended_info.any?
+              error_message += "\nExtendedInfo:"
+              retry_delay = nil
+              extended_info.each_with_index do |info, index|
+                error_message += "\n  #{index + 1}. #{info['Message']}" if info['Message']
+                error_message += " (#{info['MessageId']})" if info['MessageId']
+                error_message += " - Resolution: #{info['Resolution']}" if info['Resolution']
+                
+                # Check for ServiceTemporarilyUnavailable with retry delay
+                if info['MessageId'] == 'Base.1.12.ServiceTemporarilyUnavailable'
+                  # Extract retry delay from MessageArgs (usually first argument)
+                  if info['MessageArgs'] && info['MessageArgs'].any?
+                    retry_delay = info['MessageArgs'].first.to_i
+                    debug "🕒 iDRAC ServiceTemporarilyUnavailable detected - will wait #{retry_delay} seconds as requested", 1, :yellow
+                  end
+                end
+              end
+              
+              # If we detected a ServiceTemporarilyUnavailable error, raise a special exception
+              if retry_delay
+                raise ServiceTemporarilyUnavailableError.new(error_message, retry_delay)
+              end
+            end
+          end
+          
+          # Also add the full response body for debugging
+          debug "Full error response: #{response.body}", 1, :red if @verbosity && @verbosity > 0
+          
+        rescue JSON::ParserError => e
+          error_message += " - Raw response: #{response.body}"
+          debug "Failed to parse JSON error response: #{e.message}", 1, :yellow if @verbosity && @verbosity > 0
+        end
+        
+        raise Error, error_message
       end
     end
 

data/lib/idrac/error.rb

@@ -1,3 +1,12 @@
 module IDRAC
   class Error < StandardError; end
+  
+  class ServiceTemporarilyUnavailableError < Error
+    attr_reader :retry_delay
+    
+    def initialize(message, retry_delay)
+      super(message)
+      @retry_delay = retry_delay
+    end
+  end
 end 

data/lib/idrac/license.rb

@@ -41,6 +41,18 @@ module IDRAC
     # Extracts the iDRAC version from the license description or server header
     # @return [Integer, nil] The license version (e.g. 9) or nil if not found
     def license_version
+      # Use memoization to cache the result and avoid multiple API calls
+      @license_version ||= compute_license_version
+    end
+    
+    # Clear the cached license version (useful if iDRAC state changes)
+    def clear_license_version_cache
+      @license_version = nil
+    end
+    
+    private
+    
+    def compute_license_version
       # First try to get from license info
       license = license_info
       if license
@@ -80,8 +92,6 @@ module IDRAC
       nil
     end
     
-    private
-    
     # Attempt to get license information using Dell OEM extension path (for iDRAC 8)
     # @return [Hash, nil] License info or nil if not found
     def try_dell_oem_license_path

data/lib/idrac/network.rb

@@ -4,6 +4,40 @@ require 'json'
 
 module IDRAC
   module Network
+    # Get iDRAC version information following Dell's approach
+    def get_idrac_version_info
+      # Get iDRAC model to determine generation (following Dell's pattern)
+      manager_response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1?$select=Model,FirmwareVersion")
+      
+      if manager_response.status == 200
+        manager_data = JSON.parse(manager_response.body)
+        model = manager_data["Model"]
+        firmware_version = manager_data["FirmwareVersion"]
+        
+        # Determine iDRAC generation based on model (Dell's approach)
+        if model.include?("12") || model.include?("13")
+          idrac_generation = 8
+        elsif model.include?("14") || model.include?("15") || model.include?("16")
+          idrac_generation = 9
+        else
+          idrac_generation = 10  # iDRAC9 and newer
+        end
+        
+        # Convert firmware version to numeric for comparison (Dell's approach)
+        firmware_numeric = firmware_version.gsub(".", "").to_i if firmware_version
+        
+        {
+          generation: idrac_generation,
+          firmware_version: firmware_version,
+          firmware_numeric: firmware_numeric,
+          model: model
+        }
+      else
+        # Fallback - assume newer version if we can't determine
+        { generation: 9, firmware_version: "unknown", firmware_numeric: 0, model: "unknown" }
+      end
+    end
+    
     def get_bmc_network
       # Get the iDRAC ethernet interface
       collection_response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/EthernetInterfaces")
@@ -45,39 +79,72 @@ module IDRAC
     def set_bmc_network(ipv4: nil, mask: nil, gateway: nil, 
                         dns_primary: nil, dns_secondary: nil, hostname: nil, 
                         dhcp: false)
-      # Get the interface path first
+      puts "🔧 iDRAC set_bmc_network called with: ipv4=#{ipv4}, mask=#{mask}, gateway=#{gateway}, dhcp=#{dhcp}".cyan
+      
+      # Get iDRAC version information first (following Dell's approach)
+      begin
+        puts "🔍 Getting iDRAC version information...".yellow
+        version_info = get_idrac_version_info
+        puts "✅ Detected iDRAC Generation #{version_info[:generation]}, Firmware: #{version_info[:firmware_version]}".green
+        puts "   Model: #{version_info[:model]}, Firmware Numeric: #{version_info[:firmware_numeric]}".cyan
+      rescue => e
+        puts "❌ Error getting iDRAC version info: #{e.class} - #{e.message}".red
+        raise e
+      end
+      
+      # Get the interface path
+      puts "🔍 Getting ethernet interfaces collection...".yellow
       collection_response = authenticated_request(:get, "/redfish/v1/Managers/iDRAC.Embedded.1/EthernetInterfaces")
       
       if collection_response.status == 200
+        puts "✅ Got ethernet interfaces collection successfully".green
         collection = JSON.parse(collection_response.body)
+        puts "🔍 Collection members: #{collection["Members"]&.size || 0} interfaces found".cyan
         
         if collection["Members"] && collection["Members"].any?
           interface_path = collection["Members"][0]["@odata.id"]
+          puts "✅ Using interface path: #{interface_path}".green
           
           if dhcp
             puts "Setting iDRAC to DHCP mode...".yellow
             body = {
               "DHCPv4" => {
                 "DHCPEnabled" => true
-              },
-              "IPv4Addresses" => [{
-                "AddressOrigin" => "DHCP"
-              }]
+              }
             }
           else
             puts "Configuring iDRAC network settings...".yellow
             body = {}
             
-            # Configure static IP if provided
-            if ipv4 && mask
-              body["IPv4Addresses"] = [{
-                "Address" => ipv4,
-                "SubnetMask" => mask,
-                "Gateway" => gateway,
-                "AddressOrigin" => "Static"
-              }]
-              puts "  IP: #{ipv4}/#{mask}".cyan
-              puts "  Gateway: #{gateway}".cyan if gateway
+            # Choose API approach based on iDRAC generation and firmware version
+            if version_info[:generation] >= 9 && version_info[:firmware_numeric] > 0
+              # iDRAC9/10 - use System Configuration Profile (SCP) approach for reliable network changes
+              puts "Using iDRAC9+ SCP approach for network configuration".yellow
+              puts "  Delegating to set_idrac_ip method for reliable configuration".cyan
+              
+              # Use the existing set_idrac_ip method which uses SCP
+              return set_idrac_ip(new_ip: ipv4, new_gw: gateway, new_nm: mask)
+              
+            else
+              # iDRAC8 or older firmware - use IPv4Addresses approach
+              puts "Using legacy iDRAC8 API approach (IPv4Addresses)".yellow
+              
+              # Disable DHCP first for older versions
+              body["DHCPv4"] = {
+                "DHCPEnabled" => false
+              }
+              
+              # Configure static IP using legacy API
+              if ipv4 && mask
+                body["IPv4Addresses"] = [{
+                  "Address" => ipv4,
+                  "SubnetMask" => mask,
+                  "Gateway" => gateway,
+                  "AddressOrigin" => "Static"
+                }]
+                puts "  IP: #{ipv4}/#{mask}".cyan
+                puts "  Gateway: #{gateway}".cyan if gateway
+              end
             end
             
             # Configure DNS if provided
@@ -96,24 +163,64 @@ module IDRAC
             end
           end
           
-          response = authenticated_request(
-            :patch,
-            interface_path,
-            body: body.to_json,
-            headers: { 'Content-Type' => 'application/json' }
-          )
+          # Send the request using the version-specific approach
+          puts "🔍 Sending PATCH request to #{interface_path}".yellow
+          puts "📦 Request body: #{JSON.pretty_generate(body)}".cyan
+          
+          begin
+            response = authenticated_request(
+              :patch,
+              interface_path,
+              body: body.to_json,
+              headers: { 'Content-Type' => 'application/json' }
+            )
+            puts "✅ Got response with status: #{response.status}".green
+          rescue => e
+            puts "❌ Error sending PATCH request: #{e.class} - #{e.message}".red
+            raise e
+          end
           
           if response.status.between?(200, 299)
-            puts "iDRAC network configured successfully.".green
-            puts "WARNING: iDRAC may restart network services. Connection may be lost.".yellow if ip_address
+            puts "iDRAC network configured successfully using #{version_info[:generation] >= 9 ? 'newer' : 'legacy'} API.".green
+            
+            # For network configuration changes, automatically restart iDRAC to apply settings
+            if ipv4 && !dhcp
+              puts "Initiating iDRAC restart to apply network configuration...".yellow
+              restart_response = authenticated_request(
+                :post,
+                "/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Manager.Reset",
+                body: { "ResetType" => "GracefulRestart" }.to_json,
+                headers: { 'Content-Type' => 'application/json' }
+              )
+              
+              if restart_response.status == 204
+                puts "✓ iDRAC restart initiated successfully.".green
+                puts "Network configuration will be applied after restart (2-3 minutes).".cyan
+                puts "New IP: #{ipv4}".cyan
+              else
+                puts "⚠ iDRAC restart failed (#{restart_response.status}). You may need to restart manually.".yellow
+                puts "Configuration is saved but may not be active until restart.".yellow
+              end
+            else
+              puts "WARNING: iDRAC may restart network services. Connection may be lost.".yellow
+            end
+            
+            puts "✅ Returning true from set_bmc_network".green
             true
           else
-            raise Error, "Failed to configure iDRAC network: #{response.status} - #{response.body}"
+            # Log the error with version context for troubleshooting
+            puts "❌ Network configuration failed with status: #{response.status}".red
+            puts "🔍 Response body: #{response.body}".red
+            error_msg = "Failed to configure iDRAC network (Generation #{version_info[:generation]}, FW #{version_info[:firmware_version]}): #{response.status} - #{response.body}"
+            raise Error, error_msg
           end
         else
+          puts "❌ No ethernet interfaces found in collection".red
           raise Error, "No ethernet interfaces found"
         end
       else
+        puts "❌ Failed to get ethernet interfaces collection, status: #{collection_response.status}".red
+        puts "🔍 Response body: #{collection_response.body}".red
         raise Error, "Failed to get ethernet interfaces"
       end
     end

data/lib/idrac/session.rb

@@ -184,6 +184,10 @@ module IDRAC
       # Determine the correct session endpoint based on Redfish version
       session_endpoint = determine_session_endpoint
       
+      # Check current session count before creating new session
+      current_sessions = get_session_count
+      debug "Current active sessions: #{current_sessions}", 1, :cyan
+      
       payload = { "UserName" => username, "Password" => password }
       
       debug "Attempting to create Redfish session at #{base_url}#{session_endpoint}", 1
@@ -191,10 +195,22 @@ module IDRAC
       print_connection_debug_info if @verbosity >= 2
       
       # Try creation methods in sequence
-      return true if create_session_with_content_type(session_endpoint, payload)
-      return true if create_session_with_basic_auth(session_endpoint, payload)
-      return true if handle_max_sessions_and_retry(session_endpoint, payload)
-      return true if create_session_with_form_urlencoded(session_endpoint, payload)
+      if create_session_with_content_type(session_endpoint, payload)
+        log_session_creation_success(current_sessions)
+        return true
+      end
+      if create_session_with_basic_auth(session_endpoint, payload)
+        log_session_creation_success(current_sessions)
+        return true
+      end
+      if handle_max_sessions_and_retry(session_endpoint, payload)
+        log_session_creation_success(current_sessions)
+        return true
+      end
+      if create_session_with_form_urlencoded(session_endpoint, payload)
+        log_session_creation_success(current_sessions)
+        return true
+      end
       
       # If all attempts fail, switch to direct mode
       @direct_mode = true
@@ -678,5 +694,34 @@ module IDRAC
       debug "Defaulting to endpoint #{default_endpoint}", 1, :light_yellow
       default_endpoint
     end
+    
+    # Get current session count
+    def get_session_count
+      begin
+        sessions_url = determine_session_endpoint
+        response = request_with_basic_auth(:get, sessions_url, nil, 'application/json')
+        
+        if response.status == 200
+          sessions_data = JSON.parse(response.body)
+          count = sessions_data.dig('Members')&.size || 0
+          return count
+        end
+      rescue => e
+        debug "Error getting session count: #{e.message}", 2, :yellow
+      end
+      
+      # Return unknown if we can't determine
+      "unknown"
+    end
+    
+    # Log successful session creation with before/after count
+    def log_session_creation_success(before_count)
+      after_count = get_session_count
+      if before_count.is_a?(Integer) && after_count.is_a?(Integer)
+        debug "✅ Session created successfully! Count: #{before_count} → #{after_count} (+#{after_count - before_count})", 1, :green
+      else
+        debug "✅ Session created successfully! Previous: #{before_count}, Current: #{after_count}", 1, :green
+      end
+    end
   end
 end 

data/lib/idrac/storage.rb

@@ -384,7 +384,23 @@ module IDRAC
       end
       
       # For newer firmware, use Redfish API
-      drive_refs = drives.map { |d| { "@odata.id" => d.to_s } }
+      drive_refs = drives.map do |d|
+        # Convert drive identifier to proper @odata.id format
+        if d.to_s.start_with?('/redfish/v1/')
+          # Already in @odata.id format
+          { "@odata.id" => d.to_s }
+        else
+          # Convert FQDD to @odata.id format
+          drive_fqdd = d.to_s
+          # Build the full controller path for the drive reference
+          full_controller_path = if controller_id.start_with?('/redfish/v1/')
+            controller_id
+          else
+            "/redfish/v1/Systems/System.Embedded.1/Storage/#{controller_id}"
+          end
+          { "@odata.id" => "#{full_controller_path}/Drives/#{drive_fqdd}" }
+        end
+      end
       
       # [FastPath optimization for SSDs](https://www.dell.com/support/manuals/en-us/perc-h755/perc11_ug/fastpath?guid=guid-a9e90946-a41f-48ab-88f1-9ce514b4c414&lang=en-us)
       payload = {
@@ -406,9 +422,16 @@ module IDRAC
       
       payload["Encrypted"] = true if encrypt
       
+      # Ensure we have the full path to the controller
+      controller_path = if controller_id.start_with?('/redfish/v1/')
+        controller_id
+      else
+        "/redfish/v1/Systems/System.Embedded.1/Storage/#{controller_id}"
+      end
+      
       response = authenticated_request(
         :post, 
-        "#{controller_id}/Volumes",
+        "#{controller_path}/Volumes",
         body: payload.to_json, 
         headers: { 'Content-Type' => 'application/json' }
       )
@@ -533,21 +556,13 @@ module IDRAC
         
         return true
       else
-        error_message = "Failed to enable controller encryption. Status code: #{response.status}"
-        
-        begin
-          error_data = JSON.parse(response.body)
-          error_message += ", Message: #{error_data['error']['message']}" if error_data['error'] && error_data['error']['message']
-        rescue
-          # Ignore JSON parsing errors
-        end
-        
-        raise Error, error_message
+        # Use generic error handler which includes ExtendedInfo parsing
+        handle_response(response)
       end
     end
 
     # Disable Self-Encrypting Drive support on controller
-    def disable_local_key_management(controller_id)
+    def disable_local_key_management(controller_id:)
       payload = { "TargetFQDD": controller_id }
       
       response = authenticated_request(
@@ -568,16 +583,8 @@ module IDRAC
         
         return true
       else
-        error_message = "Failed to disable controller encryption. Status code: #{response.status}"
-        
-        begin
-          error_data = JSON.parse(response.body)
-          error_message += ", Message: #{error_data['error']['message']}" if error_data['error'] && error_data['error']['message']
-        rescue
-          # Ignore JSON parsing errors
-        end
-        
-        raise Error, error_message
+        # Use generic error handler which includes ExtendedInfo parsing
+        handle_response(response)
       end
     end
 

data/lib/idrac/system_config.rb

@@ -96,17 +96,24 @@ module IDRAC
         components = scp.is_a?(Array) ? scp : [scp]
         { "SystemConfiguration" => { "Components" => components } }
       end
+      
+      # Validate the SCP structure before sending
+      unless scp_to_apply.is_a?(Hash) && scp_to_apply["SystemConfiguration"] && scp_to_apply["SystemConfiguration"]["Components"]
+        raise ArgumentError, "Invalid SCP structure: must contain SystemConfiguration.Components"
+      end
 
       # Create the import parameters
+      # Use compact JSON generation to avoid formatting issues with Dell iDRAC
       params = { 
-        "ImportBuffer" => JSON.pretty_generate(scp_to_apply),
+        "ImportBuffer" => JSON.generate(scp_to_apply),
         "ShareParameters" => {"Target" => target},
         "ShutdownType" => "Forced",
         "HostPowerState" => reboot ? "On" : "Off"
       }
       
       debug "Importing System Configuration...", 1, :blue
-      debug "Configuration: #{JSON.pretty_generate(scp_to_apply)}", 3
+      debug "Configuration: #{JSON.pretty_generate(scp_to_apply)}", 1, :cyan
+      debug "ImportBuffer content: #{params['ImportBuffer']}", 1, :yellow
       
       # Make the API request
       response = authenticated_request(
@@ -119,7 +126,16 @@ module IDRAC
       # Check for immediate errors
       if response.headers["content-length"].to_i > 0
         debug response.inspect, 1, :red
-        return { status: :failed, error: "Failed importing SCP: #{response.body}" }
+        error_message = "Failed importing SCP: #{response.body}"
+        
+        # Check for specific schema validation errors
+        if response.body.include?("invalid characters") || response.body.include?("invalid token")
+          error_message += "\nThis may be due to JSON formatting issues. The SCP structure might contain characters not accepted by Dell iDRAC."
+        elsif response.body.include?("not compliant with configuration schema")
+          error_message += "\nThe SCP structure does not match Dell's expected schema format."
+        end
+        
+        return { status: :failed, error: error_message }
       end
       
       return handle_location(response.headers["location"])
@@ -188,7 +204,23 @@ module IDRAC
     # Convert an SCP hash back to array format
     def hash_to_scp(hash)
       hash.inject([]) do |acc, (fqdd, attributes)|
-        acc << { "FQDD" => fqdd, "Attributes" => attributes }
+        # Convert hash attributes to Dell SCP format (array of Name/Value/Set On Import objects)
+        scp_attributes = case attributes
+        when Hash
+          attributes.map do |name, value|
+            {
+              "Name" => name.to_s,
+              "Value" => value.to_s,
+              "Set On Import" => "True"
+            }
+          end
+        when Array
+          attributes # Already in correct format
+        else
+          []
+        end
+        
+        acc << { "FQDD" => fqdd, "Attributes" => scp_attributes }
         acc
       end
     end
@@ -198,6 +230,13 @@ module IDRAC
     def merge_scp(*scps)
       merged_components = {}
       
+      # Get iDRAC version for version-specific handling
+      version = begin
+        license_version.to_i
+      rescue
+        9 # Default to iDRAC 9 behavior if version detection fails
+      end
+      
       scps.compact.each do |scp|
         components = extract_components(scp)
         components.each do |component|
@@ -209,10 +248,34 @@ module IDRAC
             
             # Build hash of existing attributes by name for easy lookup
             attr_hash = {}
-            existing_attrs.each { |attr| attr_hash[attr["Name"]] = attr }
+            
+            # Handle different attribute structures between iDRAC versions
+            existing_attrs.each do |attr|
+              case attr
+              when Hash
+                # iDRAC 8 style: {"Name" => "Users.3#IpmiLanPrivilege", "Value" => "Administrator"}
+                attr_hash[attr["Name"]] = attr if attr["Name"]
+              when String
+                # iDRAC 9 style: strings or different structure - preserve as-is
+                # For strings, use the string itself as both key and value
+                attr_hash[attr] = attr
+              else
+                # Unknown structure, preserve as-is with a generated key
+                attr_hash["attr_#{attr_hash.size}"] = attr
+              end
+            end
             
             # Add/overwrite with new attributes
-            new_attrs.each { |attr| attr_hash[attr["Name"]] = attr }
+            new_attrs.each do |attr|
+              case attr
+              when Hash
+                attr_hash[attr["Name"]] = attr if attr["Name"]
+              when String
+                attr_hash[attr] = attr
+              else
+                attr_hash["attr_#{attr_hash.size}"] = attr
+              end
+            end
             
             merged_components[fqdd]["Attributes"] = attr_hash.values
           else
@@ -225,18 +288,24 @@ module IDRAC
     end
 
     # Handle location header for IP change operations. Monitors old IP until it fails,
-    # then aggressively monitors new IP with tight timeouts.
+    # then monitors job completion at new IP with proper task polling.
     def handle_location_with_ip_change(location, new_ip, timeout: 300)
       return nil if location.nil? || location.empty?
       
+      # Extract job ID from location header
+      job_id = location.split("/").last
+      debug "Extracted job ID: #{job_id}", 1, :cyan
+      
       old_ip = @host
       start_time = Time.now
       old_ip_failed = false
+      task = nil
+      tries = 0
       
-      debug "Monitoring IP change: #{old_ip} → #{new_ip}", 1, :blue
+      debug "Monitoring IP change with job tracking: #{old_ip} → #{new_ip}", 1, :blue
       
       while Time.now - start_time < timeout
-        # Try old IP until it fails, then focus on new IP
+        # Try old IP until it fails, then focus on new IP with job monitoring
         [
           old_ip_failed ? nil : [self, old_ip, "Old IP failed"],
           [create_temp_client(new_ip), new_ip, old_ip_failed ? "New IP not ready" : "Cannot reach new IP"]
@@ -244,13 +313,45 @@ module IDRAC
           
           begin
             client.login if ip == new_ip
+            
+            # Test basic connectivity first
             client.authenticated_request(:get, "/redfish/v1", timeout: 2, open_timeout: 1)
             
             if ip == new_ip
-              debug "✅ IP change successful!", 1, :green
-              @host = new_ip
-              return { status: :success, ip: new_ip }
+              # Once we can reach the new IP, check the job status
+              debug "✅ New IP reachable, checking job status...", 1, :green
+              begin
+                task_response = client.authenticated_request(:get, "/redfish/v1/TaskService/Tasks/#{job_id}", timeout: 10)
+                task = JSON.parse(task_response.body)
+                
+                debug "Job status: #{task['TaskState']} / #{task['TaskStatus']}", 1, :cyan
+                
+                if task["TaskState"] == "Completed"
+                  if task["TaskStatus"] == "OK"
+                    debug "✅ Job completed successfully!", 1, :green
+                    @host = new_ip
+                    return { status: :success, ip: new_ip, job_status: task }
+                  else
+                    # Job completed but with error
+                    msg = task['Messages']&.first&.dig('Message') rescue "N/A"
+                    attr = task['Messages']&.first&.dig('Oem', 'Dell', 'Name') rescue "N/A"
+                    error_msg = "Job failed: #{msg} : #{attr}, TaskState: #{task['TaskState']}, TaskStatus: #{task['TaskStatus']}"
+                    debug "❌ #{error_msg}", 1, :red
+                    return { status: :error, error: error_msg, job_status: task }
+                  end
+                elsif task["TaskState"] == "Running"
+                  debug "⏳ Job still running, continuing to wait...", 2, :yellow
+                  # Continue monitoring
+                else
+                  debug "⚠️  Unexpected job state: #{task['TaskState']}", 1, :yellow
+                  # Continue monitoring
+                end
+              rescue => job_error
+                debug "Failed to check job status: #{job_error.message}", 2, :yellow
+                # Continue monitoring - job might not be ready yet
+              end
             else
+              # Still on old IP, just test connectivity
               return { status: :success, ip: old_ip }
             end
           rescue => e
@@ -259,7 +360,12 @@ module IDRAC
           end
         end
         
-        sleep old_ip_failed ? 2 : 5
+        tries += 1
+        if tries > 20
+          return { status: :timeout, error: "Job monitoring exceeded maximum retries (#{tries})" }
+        end
+        
+        sleep old_ip_failed ? 6 : 5  # Wait longer during IP change
       end
       
       { status: :timeout, error: "IP change timed out after #{timeout}s. Old IP failed: #{old_ip_failed}" }

data/lib/idrac/version.rb

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

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.8.7
 platform: ruby
 authors:
 - Jonathan Siegel
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -254,7 +255,6 @@ files:
 - README.md
 - bin/console
 - bin/idrac
-- bin/idrac-tsr
 - bin/setup
 - idrac.gemspec
 - lib/idrac.rb
@@ -282,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
@@ -296,7 +297,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: API Client for Dell iDRAC
 test_files: []

data/bin/idrac-tsr

@@ -1,90 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/idrac'
-require 'optparse'
-
-options = {
-  host: ENV['IDRAC_HOST'],
-  username: ENV['IDRAC_USER'] || 'root',
-  password: ENV['IDRAC_PASSWORD'] || 'calvin',
-  output: nil,
-  data_types: [0, 1, 2], # Default: Hardware, OS, Debug
-  timeout: 600,
-  verbose: false
-}
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: idrac-tsr [options]"
-  
-  opts.on("-h", "--host HOST", "iDRAC host address") do |h|
-    options[:host] = h
-  end
-  
-  opts.on("-u", "--username USER", "Username (default: root)") do |u|
-    options[:username] = u
-  end
-  
-  opts.on("-p", "--password PASS", "Password (default: calvin)") do |p|
-    options[:password] = p
-  end
-  
-  opts.on("-o", "--output FILE", "Output filename (default: auto-generated)") do |o|
-    options[:output] = o
-  end
-  
-  opts.on("-d", "--data TYPES", "Data types to collect (comma-separated: 0=HW,1=OS,2=Debug,3=TTY,4=All)") do |d|
-    options[:data_types] = d.split(',').map(&:to_i)
-  end
-  
-  opts.on("-t", "--timeout SECONDS", Integer, "Timeout in seconds (default: 600)") do |t|
-    options[:timeout] = t
-  end
-  
-  opts.on("-v", "--verbose", "Verbose output") do
-    options[:verbose] = true
-  end
-  
-  opts.on("--help", "Show this message") do
-    puts opts
-    exit
-  end
-end.parse!
-
-if options[:host].nil?
-  puts "Error: Host is required. Use -h HOST or set IDRAC_HOST environment variable"
-  exit 1
-end
-
-begin
-  client = IDRAC::Client.new(
-    host: options[:host],
-    username: options[:username],
-    password: options[:password],
-    verify_ssl: false
-  )
-  
-  client.verbosity = options[:verbose] ? 1 : 0
-  
-  puts "Connecting to #{options[:host]}..."
-  client.login
-  
-  puts "Generating TSR logs (this may take several minutes)..."
-  result = client.generate_and_download_tsr(
-    output_file: options[:output],
-    data_selector_values: options[:data_types],
-    wait_timeout: options[:timeout]
-  )
-  
-  if result
-    puts "✓ TSR logs saved to: #{result}"
-    puts "  File size: #{File.size(result) / 1024 / 1024} MB" if File.exist?(result)
-  else
-    puts "✗ Failed to download TSR logs"
-    exit 1
-  end
-  
-  client.logout
-rescue => e
-  puts "Error: #{e.message}"
-  exit 1
-end