idrac 0.7.8 → 0.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4a991e250b073d8337d02439ef78b0456eda253169b32ff6c0fa0f55a0884f0
-  data.tar.gz: c95d65eb76ffac9a349f16d24bbb7f7fb2f137f9b1c6c0071e9f8ce4b78c61d3
+  metadata.gz: e60a1c39738e830b95e2e0c29ad603ab9c57966535ca40374b31cc37315f4138
+  data.tar.gz: 6b007a005002ff5eaf88561c3e6d717c1c6d51715aa6a994a4b72e86f1f6e2c8
 SHA512:
-  metadata.gz: 6493b01742f6f63021152a8d70a6f932396774a83f9e41f916825786ccde2257a09f96cc7144d78470b5d623cb32876c6f49534e941d81894c7c06a933bd9eed
-  data.tar.gz: 9576c7a48cf53755457c9f0f70b17fdc40d7e02985c08294b9845fa068ca8d9c0a68e4379072e4ceb62e88718540cc9ba9a0cf1766cfb245b7cf715516a98948
+  metadata.gz: 2b3014bfeb1061b6506fb9025885283015d7cd6a87868c41c832de71fdd5428dd96d6f16eb18aa2ea20ede8cb4d58d87d4f2922c2fed10958ad33ebc533469c4
+  data.tar.gz: f20ddd6b1be1f3105aead4387865e9b556cda333df23ba944915aa7805d83a28fef85a0acc7c33456b4d102d9f707dc0d4a70db470dd6726bfea08eaefd2ffd7

data/README.md

@@ -210,6 +210,60 @@ client = IDRAC.new(
 )
 ```
 
+### Basic Usage (Manual Session Management)
+
+For manual control over session lifecycle:
+
+```ruby
+require 'idrac'
+
+client = IDRAC::Client.new(
+  host: "192.168.1.100",
+  username: "root",
+  password: "calvin"
+)
+
+# Always remember to logout to clean up sessions
+begin
+  client.login
+  puts client.get_power_state
+  puts client.system_info
+ensure
+  client.logout
+end
+```
+
+### Block-based Usage (Recommended)
+
+The gem provides a block-based API that automatically handles session cleanup:
+
+```ruby
+require 'idrac'
+
+# Using IDRAC.connect - automatically handles login/logout
+IDRAC.connect(host: "192.168.1.100", username: "root", password: "calvin") do |client|
+  puts client.get_power_state
+  puts client.system_info
+  # Session is automatically cleaned up when block exits
+end
+
+# Or using Client.connect
+IDRAC::Client.connect(host: "192.168.1.100", username: "root", password: "calvin") do |client|
+  puts client.get_power_state
+  # Session cleanup is guaranteed
+end
+```
+
+### Automatic Session Cleanup
+
+The gem now includes automatic session cleanup mechanisms:
+
+1. **Finalizer**: Sessions are automatically cleaned up when the client object is garbage collected
+2. **Block-based API**: The `connect` method ensures sessions are cleaned up even if exceptions occur
+3. **Manual cleanup**: You can still call `client.logout` manually
+
+This prevents the "RAC0218: The maximum number of user sessions is reached" error that occurred when sessions were not properly cleaned up.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/idrac

@@ -22,7 +22,7 @@ module IDRAC
     class_option :port, type: :numeric, default: 443, desc: "iDRAC port"
     class_option :no_ssl, type: :boolean, default: false, desc: "Disable SSL"
     class_option :verify_ssl, type: :boolean, default: false, desc: "Enable SSL verification (not recommended for iDRAC's self-signed certificates)"
-    class_option :auto_delete_sessions, type: :boolean, default: true, desc: "Automatically delete sessions when maximum sessions are reached"
+
     class_option :retries, type: :numeric, default: 3, desc: "Number of retries for API calls"
     class_option :retry_delay, type: :numeric, default: 1, desc: "Initial delay in seconds between retries (increases exponentially)"
     class_option :verbose, type: :boolean, default: false, aliases: '-v', desc: "Enable verbose output"
@@ -1715,7 +1715,6 @@ module IDRAC
         port: options[:port],
         use_ssl: !options[:no_ssl],
         verify_ssl: options[:verify_ssl],
-        auto_delete_sessions: options[:auto_delete_sessions],
         retry_count: options[:retries],
         retry_delay: options[:retry_delay]
       )

data/lib/idrac/client.rb

@@ -9,11 +9,10 @@ require 'colorize'
 
 module IDRAC
   class Client
-    attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, :auto_delete_sessions, :session, :web, :host_header
+    attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, :session, :web, :host_header
     attr_accessor :direct_mode, :verbosity, :retry_count, :retry_delay
     
     include Power
-    include SessionUtils
     include Debuggable
     include Jobs
     include Lifecycle
@@ -25,7 +24,7 @@ module IDRAC
     include SystemConfig
     include Utility
 
-    def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: false, direct_mode: false, auto_delete_sessions: true, retry_count: 3, retry_delay: 1, host_header: nil)
+    def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: false, direct_mode: false, retry_count: 3, retry_delay: 1, host_header: nil)
       @host = host
       @username = username
       @password = password
@@ -33,7 +32,6 @@ module IDRAC
       @use_ssl = use_ssl
       @verify_ssl = verify_ssl
       @direct_mode = direct_mode
-      @auto_delete_sessions = auto_delete_sessions
       @host_header = host_header
       @verbosity = 0
       @retry_count = retry_count
@@ -42,6 +40,34 @@ module IDRAC
       # Initialize the session and web classes
       @session = Session.new(self)
       @web = Web.new(self)
+      
+      # Add finalizer to ensure sessions are cleaned up
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@session, @web))
+    end
+
+    # Finalizer to clean up sessions when object is garbage collected
+    def self.finalizer(session, web)
+      proc do
+        begin
+          session.delete if session.x_auth_token
+          web.logout if web.session_id
+        rescue
+          # Ignore errors during cleanup
+        end
+      end
+    end
+
+    # Primary interface - block-based API that ensures session cleanup
+    def self.connect(host:, username:, password:, **options)
+      client = new(host: host, username: username, password: password, **options)
+      return client unless block_given?
+      
+      begin
+        client.login
+        yield client
+      ensure
+        client.logout
+      end
     end
 
     def connection
@@ -87,9 +113,17 @@ module IDRAC
     end
 
     # Send an authenticated request to the iDRAC
-    def authenticated_request(method, path, options = {})
+    def authenticated_request(method, path, body: nil, headers: {}, timeout: nil, open_timeout: nil, **options)
+      # Build options hash with all parameters
+      request_options = {
+        body: body,
+        headers: headers,
+        timeout: timeout,
+        open_timeout: open_timeout
+      }.merge(options).compact
+      
       with_retries do
-        _perform_authenticated_request(method, path, options)
+        _perform_authenticated_request(method, path, request_options)
       end
     end
 
@@ -109,145 +143,112 @@ module IDRAC
         raise Error, "Failed to authenticate after #{@retry_count} retries"
       end
       
-      # Form the full URL
-      full_url = "#{base_url}/redfish/v1".chomp('/') + '/' + path.sub(/^\//, '')
-      
-      # Log the request
       debug "Authenticated request: #{method.to_s.upcase} #{path}", 1
       
-      # Extract options
+      # Extract options and prepare headers
       body = options[:body]
       headers = options[:headers] || {}
+      timeout = options[:timeout]
+      open_timeout = options[:open_timeout]
       
-      # Add client headers
       headers['User-Agent'] ||= 'iDRAC Ruby Client'
       headers['Accept'] ||= 'application/json'
       headers['Host'] = @host_header if @host_header
       
-      # If we're in direct mode, use Basic Auth
+      # Determine authentication method and set headers
       if @direct_mode
-        # Create Basic Auth header
-        auth_header = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
-        headers['Authorization'] = auth_header
+        headers['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
         debug "Using Basic Auth for request (direct mode)", 2
-        
-        begin
-          # Make the request directly
-          response = session.connection.run_request(
-            method,
-            path.sub(/^\//, ''),
-            body,
-            headers
-          )
-          
-          debug "Response status: #{response.status}", 2
-          
-          # Even in direct mode, check for authentication issues
-          if response.status == 401 || response.status == 403
-            debug "Authentication failed in direct mode, retrying with new credentials...", 1, :light_yellow
-            sleep(retry_count + 1) # Add some delay before retry
-            return _perform_authenticated_request(method, path, options, retry_count + 1)
-          end
-          
-          return response
-        rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::SSLError => e
-          # Old iDRACs (e.g. R630s) can have occasional connection issues--even SSLError is common
-          debug "Connection error in direct mode: #{e.message}", 1, :red
-          sleep(retry_count + 1) # Add some delay before retry
-          return _perform_authenticated_request(method, path, options, retry_count + 1)
-        rescue => e
-          debugger
-          debug "Error during direct mode request: #{e.message}", 1, :red
-          # sleep(retry_count + 1) # Add some delay before retry
-          # return _perform_authenticated_request(method, path, options, retry_count + 1)
-          raise Error, "Error during authenticated request: #{e.message}"
-        end
-      # Use Redfish session token if available
       elsif session.x_auth_token
-        begin
-          headers['X-Auth-Token'] = session.x_auth_token
-          
-          debug "Using X-Auth-Token for authentication", 2
-          debug "Request headers: #{headers.reject { |k,v| k =~ /auth/i }.to_json}", 3
-          debug "Request body: #{body.to_s[0..500]}", 3 if body
-          
-          response = session.connection.run_request(
-            method,
-            path.sub(/^\//, ''),
-            body,
-            headers
-          )
-          
-          debug "Response status: #{response.status}", 2
-          debug "Response headers: #{response.headers.to_json}", 3
-          debug "Response body: #{response.body.to_s[0..500]}", 3 if response.body
-          
-          # Handle session expiration
-          if response.status == 401 || response.status == 403
-            debug "Session expired or invalid, creating a new session...", 1, :light_yellow
-            
-            # If session.delete returns true, the session was successfully deleted
-            if session.delete
-              debug "Successfully cleared expired session", 1, :green
-            end
-            
-            # Try to create a new session
-            if session.create
-              debug "Successfully created a new session after expiration, retrying request...", 1, :green
-              return _perform_authenticated_request(method, path, options, retry_count + 1)
-            else
-              debug "Failed to create a new session after expiration, falling back to direct mode...", 1, :light_yellow
-              @direct_mode = true
-              return _perform_authenticated_request(method, path, options, retry_count + 1)
-            end
-          end
-          
-          return response
-        rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
-          debug "Connection error: #{e.message}", 1, :red
-          sleep(retry_count + 1) # Add some delay before retry
-          
-          # If we still have the token, try to reuse it
-          if session.x_auth_token
-            debug "Retrying with existing token after connection error", 1, :light_yellow
-            return _perform_authenticated_request(method, path, options, retry_count + 1)
-          else
-            # Otherwise try to create a new session
-            debug "Trying to create a new session after connection error", 1, :light_yellow
-            if session.create
-              debug "Successfully created a new session after connection error", 1, :green
-              return _perform_authenticated_request(method, path, options, retry_count + 1)
-            else
-              debug "Failed to create session after connection error, falling back to direct mode", 1, :light_yellow
-              @direct_mode = true
-              return _perform_authenticated_request(method, path, options, retry_count + 1)
-            end
-          end
-        rescue => e
-          debug "Error during authenticated request (token mode): #{e.message}", 1, :red
-          
-          # Try to create a new session
-          if session.create
-            debug "Successfully created a new session after error, retrying request...", 1, :green
-            return _perform_authenticated_request(method, path, options, retry_count + 1)
-          else
-            debug "Failed to create a new session after error, falling back to direct mode...", 1, :light_yellow
-            @direct_mode = true
-            return _perform_authenticated_request(method, path, options, retry_count + 1)
-          end
-        end
+        headers['X-Auth-Token'] = session.x_auth_token
+        debug "Using X-Auth-Token for authentication", 2
+      end
+      
+      # Make request with timeout handling
+      response = make_request_with_timeouts(method, path, body, headers, timeout, open_timeout)
+      
+      # Handle authentication and connection errors
+      case response.status
+      when 401, 403
+        handle_auth_failure(method, path, options, retry_count)
+      else
+        debug "Response status: #{response.status}", 2
+        response
+      end
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::SSLError => e
+      handle_connection_error(e, method, path, options, retry_count)
+    rescue => e
+      handle_general_error(e, method, path, options, retry_count)
+    end
+    
+    # Make request with timeout handling
+    def make_request_with_timeouts(method, path, body, headers, timeout, open_timeout)
+      conn = session.connection
+      original_timeout = conn.options.timeout
+      original_open_timeout = conn.options.open_timeout
+      
+      begin
+        conn.options.timeout = timeout if timeout
+        conn.options.open_timeout = open_timeout if open_timeout
+        
+        conn.run_request(method, path.sub(/^\//, ''), body, headers)
+      ensure
+        conn.options.timeout = original_timeout
+        conn.options.open_timeout = original_open_timeout
+      end
+    end
+    
+    # Handle authentication failures
+    def handle_auth_failure(method, path, options, retry_count)
+      if @direct_mode
+        debug "Authentication failed in direct mode, retrying...", 1, :light_yellow
+        sleep(retry_count + 1)
+        return _perform_authenticated_request(method, path, options, retry_count + 1)
       else
-        # If we don't have a token, try to create a session
+        debug "Session expired, creating new session...", 1, :light_yellow
+        session.delete if session.x_auth_token
+        
         if session.create
-          debug "Successfully created a new session, making request...", 1, :green
+          debug "New session created, retrying request...", 1, :green
           return _perform_authenticated_request(method, path, options, retry_count + 1)
         else
-          debug "Failed to create a session, falling back to direct mode...", 1, :light_yellow
+          debug "Session creation failed, falling back to direct mode...", 1, :light_yellow
           @direct_mode = true
           return _perform_authenticated_request(method, path, options, retry_count + 1)
         end
       end
     end
+    
+    # Handle connection errors
+    def handle_connection_error(error, method, path, options, retry_count)
+      debug "Connection error: #{error.message}", 1, :red
+      sleep(retry_count + 1)
+      
+      if @direct_mode || session.x_auth_token
+        return _perform_authenticated_request(method, path, options, retry_count + 1)
+      elsif session.create
+        debug "Created new session after connection error", 1, :green
+        return _perform_authenticated_request(method, path, options, retry_count + 1)
+      else
+        @direct_mode = true
+        return _perform_authenticated_request(method, path, options, retry_count + 1)
+      end
+    end
+    
+    # Handle general errors
+    def handle_general_error(error, method, path, options, retry_count)
+      debug "Error during request: #{error.message}", 1, :red
+      
+      if @direct_mode
+        raise Error, "Error during authenticated request: #{error.message}"
+      elsif session.create
+        debug "Created new session after error, retrying...", 1, :green
+        return _perform_authenticated_request(method, path, options, retry_count + 1)
+      else
+        @direct_mode = true
+        return _perform_authenticated_request(method, path, options, retry_count + 1)
+      end
+    end
 
     def _perform_get(path:, headers: {})
       # For screenshot functionality, we need to use the WebUI cookies

data/lib/idrac/session.rb

@@ -9,7 +9,7 @@ require 'socket'
 module IDRAC
   class Session
     attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, 
-                :x_auth_token, :session_location, :direct_mode, :auto_delete_sessions, :host_header
+                :x_auth_token, :session_location, :direct_mode, :host_header
     attr_accessor :verbosity
     
     include Debuggable
@@ -27,7 +27,6 @@ module IDRAC
       @session_location = nil
       @direct_mode = client.direct_mode
       @sessions_maxed = false
-      @auto_delete_sessions = client.auto_delete_sessions
       @verbosity = client.respond_to?(:verbosity) ? client.verbosity : 0
     end
 
@@ -76,7 +75,7 @@ module IDRAC
       
       false
     end
-
+    
     # Delete all sessions using Basic Authentication
     def delete_all_sessions_with_basic_auth
       debug "Attempting to delete all sessions using Basic Authentication...", 1
@@ -143,7 +142,7 @@ module IDRAC
         return try_delete_latest_sessions
       end
     end
-    
+
     # Try to delete sessions by direct URL when we can't list sessions
     def try_delete_latest_sessions
       # Try to delete sessions by direct URL when we can't list sessions
@@ -209,71 +208,24 @@ module IDRAC
       begin
         debug "Deleting Redfish session...", 1
         
-        if @session_location
-          # Use the X-Auth-Token for authentication
-          headers = { 'X-Auth-Token' => @x_auth_token }
-          
-          begin
-            response = connection.delete(@session_location) do |req|
-              req.headers.merge!(headers)
-            end
-            
-            if response.status == 200 || response.status == 204
-              debug "Redfish session deleted successfully", 1, :green
-              @x_auth_token = nil
-              @session_location = nil
-              return true
-            end
-          rescue => session_e
-            debug "Error during session deletion via location: #{session_e.message}", 1, :yellow
-            # Continue to try basic auth method
-          end
+        # Try to delete via session location first
+        if @session_location && delete_via_location
+          return true
         end
         
-        # If deleting via session location fails or there's no session location,
-        # try to delete by using the basic auth method
-        if @x_auth_token
-          # Try to determine session ID from the X-Auth-Token or session_location
-          session_id = nil
-          
-          # Extract session ID from location if available
-          if @session_location
-            if @session_location =~ /\/([^\/]+)$/
-              session_id = $1
-            end
-          end
-          
-          # If we have an extracted session ID
-          if session_id
-            debug "Trying to delete session by ID #{session_id}", 1
-            
-            begin
-              endpoint = determine_session_endpoint
-              delete_url = "#{endpoint}/#{session_id}"
-              
-              delete_response = request_with_basic_auth(:delete, delete_url, nil)
-              
-              if delete_response.status == 200 || delete_response.status == 204
-                debug "Successfully deleted session via ID", 1, :green
-                @x_auth_token = nil
-                @session_location = nil
-                return true
-              end
-            rescue => id_e
-              debug "Error during session deletion via ID: #{id_e.message}", 1, :yellow
-            end
-          end
-          
-          # Last resort: clear the token variable even if we couldn't properly delete it
-          debug "Clearing session token internally", 1, :yellow
-          @x_auth_token = nil
-          @session_location = nil
+        # Try to delete via session ID
+        if @x_auth_token && delete_via_session_id
+          return true
         end
         
+        # Clear token variables even if deletion failed
+        debug "Clearing session token internally", 1, :yellow
+        @x_auth_token = nil
+        @session_location = nil
         return false
       rescue => e
         debug "Error during Redfish session deletion: #{e.message}", 1, :red
-        # Clear token variable anyway
+        # Clear token variables anyway
         @x_auth_token = nil
         @session_location = nil
         return false
@@ -527,45 +479,39 @@ module IDRAC
       return false unless @sessions_maxed
       
       debug "Maximum sessions reached, attempting to clear sessions", 1
-      if @auto_delete_sessions
-        if force_clear_sessions
-          debug "Successfully cleared sessions, trying to create a new session", 1, :green
-          
-          # Give the iDRAC a moment to process the session deletions
-          sleep(3)
+      if force_clear_sessions
+        debug "Successfully cleared sessions, trying to create a new session", 1, :green
+        
+        # Give the iDRAC a moment to process the session deletions
+        sleep(3)
+        
+        # Try one more time after clearing with form-urlencoded
+        begin
+          response = connection.post(url) do |req|
+            req.headers['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
+            req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+            req.headers['Host'] = host_header if host_header
+            req.body = "UserName=#{URI.encode_www_form_component(username)}&Password=#{URI.encode_www_form_component(password)}"
+          end
           
-          # Try one more time after clearing with form-urlencoded
-          begin
-            response = connection.post(url) do |req|
-              req.headers['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
-              req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
-              req.headers['Host'] = host_header if host_header
-              req.body = "UserName=#{URI.encode_www_form_component(username)}&Password=#{URI.encode_www_form_component(password)}"
-            end
-            
-            if process_session_response(response)
-              debug "Redfish session created successfully after clearing sessions", 1, :green
-              return true
-            else
-              debug "Failed to create Redfish session after clearing sessions: #{response.status} - #{response.body}", 1, :red
-              # If still failing, try direct mode
-              debug "Falling back to direct mode", 1, :light_yellow
-              @direct_mode = true
-              return false
-            end
-          rescue => e
-            debug "Error during session creation after clearing: #{e.class.name}: #{e.message}", 1, :red
+          if process_session_response(response)
+            debug "Redfish session created successfully after clearing sessions", 1, :green
+            return true
+          else
+            debug "Failed to create Redfish session after clearing sessions: #{response.status} - #{response.body}", 1, :red
+            # If still failing, try direct mode
             debug "Falling back to direct mode", 1, :light_yellow
             @direct_mode = true
             return false
           end
-        else
-          debug "Failed to clear sessions, switching to direct mode", 1, :light_yellow
+        rescue => e
+          debug "Error during session creation after clearing: #{e.class.name}: #{e.message}", 1, :red
+          debug "Falling back to direct mode", 1, :light_yellow
           @direct_mode = true
           return false
         end
       else
-        debug "Auto delete sessions is disabled, switching to direct mode", 1, :light_yellow
+        debug "Failed to clear sessions, switching to direct mode", 1, :light_yellow
         @direct_mode = true
         return false
       end
@@ -635,6 +581,61 @@ module IDRAC
       end
     end
 
+    # Delete session using the session location URL
+    def delete_via_location
+      headers = { 'X-Auth-Token' => @x_auth_token }
+      
+      response = connection.delete(@session_location) do |req|
+        req.headers.merge!(headers)
+      end
+      
+      if response.status == 200 || response.status == 204
+        debug "Redfish session deleted successfully via location", 1, :green
+        @x_auth_token = nil
+        @session_location = nil
+        return true
+      end
+      
+      false
+    rescue => e
+      debug "Error during session deletion via location: #{e.message}", 1, :yellow
+      false
+    end
+    
+    # Delete session using session ID extracted from location or token
+    def delete_via_session_id
+      session_id = extract_session_id
+      return false unless session_id
+      
+      debug "Trying to delete session by ID #{session_id}", 1
+      
+      endpoint = determine_session_endpoint
+      delete_url = "#{endpoint}/#{session_id}"
+      
+      delete_response = request_with_basic_auth(:delete, delete_url, nil)
+      
+      if delete_response.status == 200 || delete_response.status == 204
+        debug "Successfully deleted session via ID", 1, :green
+        @x_auth_token = nil
+        @session_location = nil
+        return true
+      end
+      
+      false
+    rescue => e
+      debug "Error during session deletion via ID: #{e.message}", 1, :yellow
+      false
+    end
+    
+    # Extract session ID from location URL
+    def extract_session_id
+      return nil unless @session_location
+      
+      if @session_location =~ /\/([^\/]+)$/
+        $1
+      end
+    end
+
     # Determine the correct session endpoint based on Redfish version
     def determine_session_endpoint
       begin
@@ -655,27 +656,21 @@ module IDRAC
               
               # For version 1.17.0 and below, use the /redfish/v1/Sessions endpoint
               # For newer versions, use /redfish/v1/SessionService/Sessions
-              if Gem::Version.new(redfish_version) <= Gem::Version.new('1.17.0')
-                endpoint = '/redfish/v1/Sessions'
-                debug "Using endpoint #{endpoint} for Redfish version #{redfish_version}", 1
-                return endpoint
-              else
-                endpoint = '/redfish/v1/SessionService/Sessions'
-                debug "Using endpoint #{endpoint} for Redfish version #{redfish_version}", 1
-                return endpoint
-              end
+              endpoint = Gem::Version.new(redfish_version) <= Gem::Version.new('1.17.0') ? 
+                         '/redfish/v1/Sessions' : 
+                         '/redfish/v1/SessionService/Sessions'
+              
+              debug "Using endpoint #{endpoint} for Redfish version #{redfish_version}", 1
+              return endpoint
             end
           rescue JSON::ParserError => e
             debug "Error parsing Redfish version: #{e.message}", 1, :red
-            debug e.backtrace.join("\n"), 3 if e.backtrace && @verbosity >= 3
           rescue => e
             debug "Error determining Redfish version: #{e.message}", 1, :red
-            debug e.backtrace.join("\n"), 3 if e.backtrace && @verbosity >= 3
           end
         end
       rescue => e
         debug "Error checking Redfish version: #{e.message}", 1, :red
-        debug e.backtrace.join("\n"), 3 if e.backtrace && @verbosity >= 3
       end
       
       # Default to /redfish/v1/Sessions if we can't determine version
@@ -684,93 +679,4 @@ module IDRAC
       default_endpoint
     end
   end
-
-  # Module containing extracted session methods to be included in Client
-  module SessionUtils
-    def force_clear_sessions
-      debug = ->(msg, level=1, color=:light_cyan) { 
-        verbosity = respond_to?(:verbosity) ? verbosity : 0
-        return unless verbosity >= level
-        msg = msg.send(color) if color && msg.respond_to?(color)
-        puts msg
-      }
-      
-      debug.call "Attempting to force clear all sessions...", 1
-      
-      if delete_all_sessions_with_basic_auth
-        debug.call "Successfully cleared sessions using Basic Auth", 1, :green
-        true
-      else
-        debug.call "Failed to clear sessions using Basic Auth", 1, :red
-        false
-      end
-    end
-
-    # Delete all sessions using Basic Authentication
-    def delete_all_sessions_with_basic_auth
-      debug = ->(msg, level=1, color=:light_cyan) { 
-        verbosity = respond_to?(:verbosity) ? verbosity : 0
-        return unless verbosity >= level
-        msg = msg.send(color) if color && msg.respond_to?(color)
-        puts msg
-      }
-      
-      debug.call "Attempting to delete all sessions using Basic Authentication...", 1
-      
-      # First, get the list of sessions
-      sessions_url = session&.determine_session_endpoint || '/redfish/v1/Sessions'
-      
-      begin
-        # Get the list of sessions
-        response = authenticated_request(:get, sessions_url)
-        
-        if response.status != 200
-          debug.call "Failed to get sessions list: #{response.status} - #{response.body}", 1, :red
-          return false
-        end
-        
-        # Parse the response to get session IDs
-        begin
-          sessions_data = JSON.parse(response.body)
-          
-          if sessions_data['Members'] && sessions_data['Members'].any?
-            debug.call "Found #{sessions_data['Members'].count} active sessions", 1, :light_yellow
-            
-            # Delete each session
-            success = true
-            sessions_data['Members'].each do |session|
-              session_url = session['@odata.id']
-              
-              # Skip if no URL
-              next unless session_url
-              
-              # Delete the session
-              delete_response = authenticated_request(:delete, session_url)
-              
-              if delete_response.status == 200 || delete_response.status == 204
-                debug.call "Successfully deleted session: #{session_url}", 1, :green
-              else
-                debug.call "Failed to delete session #{session_url}: #{delete_response.status}", 1, :red
-                success = false
-              end
-              
-              # Small delay between deletions
-              sleep(1)
-            end
-            
-            return success
-          else
-            debug.call "No active sessions found", 1, :light_yellow
-            return true
-          end
-        rescue JSON::ParserError => e
-          debug.call "Error parsing sessions response: #{e.message}", 1, :red
-          return false
-        end
-      rescue => e
-        debug.call "Error during session deletion with Basic Auth: #{e.message}", 1, :red
-        return false
-      end
-    end
-  end
 end 

data/lib/idrac/system_config.rb

@@ -5,74 +5,52 @@ module IDRAC
   module SystemConfig
     # This assigns the iDRAC IP to be a STATIC IP.
     def set_idrac_ip(new_ip:, new_gw:, new_nm:, vnc_password: "calvin", vnc_port: 5901)
-      scp = get_system_configuration_profile(target: "iDRAC")
-      pp scp
-      ## We want to access the iDRAC web server even when IPs don't match (and they won't when we port forward local host):
-      set_scp_attribute(scp, "WebServer.1#HostHeaderCheck", "Disabled")
-      ## We want VirtualMedia to be enabled so we can mount ISOs: set_scp_attribute(scp, "VirtualMedia.1#Enable", "Enabled")
-      set_scp_attribute(scp, "VirtualMedia.1#EncryptEnable", "Disabled")
-      ## We want to access VNC Server on specified port for screenshots and without SSL:
-      set_scp_attribute(scp, "VNCServer.1#Enable", "Enabled")
-      set_scp_attribute(scp, "VNCServer.1#Port", vnc_port.to_s)
-      set_scp_attribute(scp, "VNCServer.1#SSLEncryptionBitLength", "Disabled")
-      # And password calvin
-      set_scp_attribute(scp, "VNCServer.1#Password", vnc_password)
-      # Disable DHCP on management NIC
-      set_scp_attribute(scp, "IPv4.1#DHCPEnable", "Disabled")
-      if drac_license_version.to_i == 8
-        # We want to use HTML for the virtual console
-        set_scp_attribute(scp, "VirtualConsole.1#PluginType", "HTML5")
-        # We want static IP for the iDRAC
-        set_scp_attribute(scp, "IPv4.1#Address", new_ip)
-        set_scp_attribute(scp, "IPv4.1#Gateway", new_gw)
-        set_scp_attribute(scp, "IPv4.1#Netmask", new_nm)
-      elsif drac_license_version.to_i == 9
-        # We want static IP for the iDRAC
-        set_scp_attribute(scp, "IPv4Static.1#Address", new_ip)
-        set_scp_attribute(scp, "IPv4Static.1#Gateway", new_gw)
-        set_scp_attribute(scp, "IPv4Static.1#Netmask", new_nm)
-        # {"Name"=>"SerialCapture.1#Enable", "Value"=>"Disabled", "Set On Import"=>"True", "Comment"=>"Read and Write"},
+      # Cache license version to avoid multiple iDRAC calls
+      version = license_version.to_i
+      
+      case version
+      when 8
+        ipv4_prefix = "IPv4"
+        settings = { "VirtualConsole.1#PluginType" => "HTML5" }
+      when 9
+        ipv4_prefix = "IPv4Static"
+        settings = {}
       else
-        raise "Unknown iDRAC version"
-      end
-      while true
-        res = self.post(path: "Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ImportSystemConfiguration", params: {"ImportBuffer": scp.to_json, "ShareParameters": {"Target": "iDRAC"}})
-        # A successful JOB will have a location header with a job id.
-        # We can get a busy message instead if we've sent too many iDRAC jobs back-to-back, so we check for that here.
-        if res[:headers]["location"].present?
-          # We have a job id, so we're good to go.
-          break
-        else
-          # Depending on iDRAC version content-length may be present or not.
-          # res[:headers]["content-length"].blank?
-          msg = res['body']['error']['@Message.ExtendedInfo'].first['Message']
-          details = res['body']['error']['@Message.ExtendedInfo'].first['Resolution']
-          # msg     => "A job operation is already running. Retry the operation after the existing job is completed."
-          # details => "Wait until the running job is completed or delete the scheduled job and retry the operation."
-          if details =~ /Wait until the running job is completed/
-            sleep 10
-          else
-            Rails.logger.warn msg+details
-            raise "failed configuring static ip, message: #{msg}, details: #{details}"
-          end
-        end
+        raise Error, "Unsupported iDRAC version: #{version}. Supported versions: 8, 9"
       end
       
-      # Allow some time for the iDRAC to prepare before checking the task status
-      sleep 3
+      # Build base settings for all versions
+      settings.merge!({
+        "WebServer.1#HostHeaderCheck" => "Disabled",
+        "VirtualMedia.1#EncryptEnable" => "Disabled", 
+        "VNCServer.1#Enable" => "Enabled",
+        "VNCServer.1#Port" => vnc_port.to_s,
+        "VNCServer.1#SSLEncryptionBitLength" => "Disabled",
+        "VNCServer.1#Password" => vnc_password,
+        "IPv4.1#DHCPEnable" => "Disabled", # only applies to iDRAC 8
+        "#{ipv4_prefix}.1#Address" => new_ip, # only applies to iDRAC 9
+        "#{ipv4_prefix}.1#Gateway" => new_gw,
+        "#{ipv4_prefix}.1#Netmask" => new_nm
+      })
       
-      # Use handle_location to monitor task progress
-      result = handle_location(res[:headers]["location"])
+      # Build SCP from scratch instead of getting full profile
+      scp_component = make_scp(fqdd: "iDRAC.Embedded.1", attributes: settings)
+      scp = { "SystemConfiguration" => { "Components" => [scp_component] } }
       
-      # Check if the operation succeeded
-      if result[:status] != :success
-        # Extract error details if available
-        message = result[:messages].first rescue "N/A" 
-        error = result[:error] || "Unknown error"
-        raise "Failed configuring static IP: #{message} - #{error}"
+      # Submit configuration with job availability handling
+      res = wait_for_job_availability do
+        authenticated_request(:post, 
+          "/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ImportSystemConfiguration",
+          body: {"ImportBuffer": scp.to_json, "ShareParameters": {"Target": "iDRAC"}}.to_json,
+          headers: {"Content-Type" => "application/json"}
+        )
       end
       
-      return true
+      sleep 3  # Allow iDRAC to prepare
+      result = handle_location_with_ip_change(res.headers["location"], new_ip)
+      
+      raise "Failed configuring static IP: #{result[:messages]&.first || result[:error] || "Unknown error"}" if result[:status] != :success
+      true
     end
 
 
@@ -92,56 +70,7 @@ module IDRAC
       return scp
     end
 
-    # Set an attribute in a system configuration profile
-    def set_scp_attribute(scp, name, value)
-      # Make a deep copy to avoid modifying the original
-      scp_copy = JSON.parse(scp.to_json)
-      
-      # Clear unrelated attributes for quicker transfer
-      scp_copy["SystemConfiguration"].delete("Comments")
-      scp_copy["SystemConfiguration"].delete("TimeStamp")
-      scp_copy["SystemConfiguration"].delete("ServiceTag")
-      scp_copy["SystemConfiguration"].delete("Model")
 
-      # Skip these attribute groups to make the transfer faster
-      excluded_prefixes = [
-        "User", "Telemetry", "SecurityCertificate", "AutoUpdate", "PCIe", "LDAP", "ADGroup", "ActiveDirectory",
-        "IPMILan", "EmailAlert", "SNMP", "IPBlocking", "IPMI", "Security", "RFS", "OS-BMC", "SupportAssist",
-        "Redfish", "RedfishEventing", "Autodiscovery", "SEKM-LKC", "Telco-EdgeServer", "8021XSecurity", "SPDM",
-        "InventoryHash", "RSASecurID2FA", "USB", "NIC", "IPv6", "NTP", "Logging", "IOIDOpt", "SSHCrypto",
-        "RemoteHosts", "SysLog", "Time", "SmartCard", "ACME", "ServiceModule", "Lockdown",
-        "DefaultCredentialMitigation", "AutoOSLockGroup", "LocalSecurity", "IntegratedDatacenter",
-        "SecureDefaultPassword.1#ForceChangePassword", "SwitchConnectionView.1#Enable", "GroupManager.1",
-        "ASRConfig.1#Enable", "SerialCapture.1#Enable", "CertificateManagement.1",
-        "Update", "SSH", "SysInfo", "GUI"
-      ]
-      
-      # Remove excluded attribute groups
-      if scp_copy["SystemConfiguration"]["Components"] && 
-         scp_copy["SystemConfiguration"]["Components"][0] && 
-         scp_copy["SystemConfiguration"]["Components"][0]["Attributes"]
-        
-        attrs = scp_copy["SystemConfiguration"]["Components"][0]["Attributes"]
-        
-        attrs.reject! do |attr|
-          excluded_prefixes.any? { |prefix| attr["Name"] =~ /\A#{prefix}/ }
-        end
-        
-        # Update or add the specified attribute
-        if attrs.find { |a| a["Name"] == name }.nil?
-          # Attribute doesn't exist, create it
-          attrs << { "Name" => name, "Value" => value, "Set On Import" => "True" }
-        else
-          # Update existing attribute
-          attrs.find { |a| a["Name"] == name }["Value"] = value
-          attrs.find { |a| a["Name"] == name }["Set On Import"] = "True"
-        end
-        
-        scp_copy["SystemConfiguration"]["Components"][0]["Attributes"] = attrs
-      end
-      
-      return scp_copy
-    end
 
     # Helper method to normalize enabled/disabled values
     def normalize_enabled_value(v)
@@ -264,52 +193,78 @@ module IDRAC
       end
     end
 
-    # Merge two SCPs together
-    def merge_scp(scp1, scp2)
-      return scp1 || scp2 unless scp1 && scp2 # Return the one that's not nil if either is nil
-      
-      # Make them both arrays in case they aren't
-      scp1_array = scp1.is_a?(Array) ? scp1 : [scp1]
-      scp2_array = scp2.is_a?(Array) ? scp2 : [scp2]
-      
-      # Convert to hashes for merging
-      hash1 = scp_to_hash(scp1_array)
-      hash2 = scp_to_hash(scp2_array)
-      
-      # Perform deep merge
-      merged = deep_merge(hash1, hash2)
-      
-      # Convert back to SCP array format
-      hash_to_scp(merged)
-    end
 
-    private
 
-    # Helper method for deep merging of hashes
-    def deep_merge(hash1, hash2)
-      result = hash1.dup
+    # Handle location header for IP change operations. Monitors old IP until it fails,
+    # then aggressively monitors new IP with tight timeouts.
+    def handle_location_with_ip_change(location, new_ip, timeout: 300)
+      return nil if location.nil? || location.empty?
       
-      hash2.each do |key, value|
-        if result[key].is_a?(Array) && value.is_a?(Array)
-          # For arrays of attributes, merge by name
-          existing_names = result[key].map { |attr| attr["Name"] }
+      old_ip = @host
+      start_time = Time.now
+      old_ip_failed = false
+      
+      debug "Monitoring IP change: #{old_ip} → #{new_ip}", 1, :blue
+      
+      while Time.now - start_time < timeout
+        # Try old IP until it fails, then focus on new IP
+        [
+          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"]
+        ].compact.each do |client, ip, error_prefix|
           
-          value.each do |attr|
-            if existing_index = existing_names.index(attr["Name"])
-              # Update existing attribute
-              result[key][existing_index] = attr
+          begin
+            client.login if ip == new_ip
+            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 }
             else
-              # Add new attribute
-              result[key] << attr
+              return { status: :success, ip: old_ip }
             end
+          rescue => e
+            debug "#{error_prefix}: #{e.message}", ip == new_ip ? 2 : 1, ip == new_ip ? :gray : :yellow
+            old_ip_failed = true if ip == old_ip
           end
-        else
-          # For other values, just replace
-          result[key] = value
         end
+        
+        sleep old_ip_failed ? 2 : 5
       end
       
-      result
+      { status: :timeout, error: "IP change timed out after #{timeout}s. Old IP failed: #{old_ip_failed}" }
     end
+    
+    private
+    
+    # Wait for job availability, retrying if busy
+    def wait_for_job_availability
+      loop do
+        res = yield
+        return res if res.headers["location"].present?
+        
+        msg = res['error']['@Message.ExtendedInfo'].first['Message']
+        details = res['error']['@Message.ExtendedInfo'].first['Resolution']
+        
+        if details =~ /Wait until the running job is completed/
+          sleep 10
+        else
+          Rails.logger.warn "#{msg}#{details}" if defined?(Rails)
+          raise "Failed configuring static IP: #{msg}, #{details}"
+        end
+      end
+    end
+    
+    # Create temporary client for new IP monitoring  
+    def create_temp_client(new_ip)
+      self.class.new(
+        host: new_ip, username: @username, password: @password,
+        port: @port, use_ssl: @use_ssl, verify_ssl: @verify_ssl,
+        retry_count: 1, retry_delay: 1
+      ).tap { |c| c.verbosity = [@verbosity - 1, 0].max }
+    end
+
+    private
   end
 end 

data/lib/idrac/version.rb

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

data/lib/idrac/web.rb

@@ -60,9 +60,9 @@ module IDRAC
         elsif response.code == 400 && response.body.include?("maximum number of user sessions")
           puts "Maximum sessions reached during WebUI login".light_red
           
-          # Try to clear sessions if auto_delete_sessions is enabled
-          if client.auto_delete_sessions && !@tried_clearing_sessions
-            puts "Auto-delete sessions is enabled, attempting to clear sessions".light_cyan
+          # Try to clear sessions automatically
+          if !@tried_clearing_sessions
+            puts "Attempting to clear sessions automatically".light_cyan
             @tried_clearing_sessions = true
             
             if client.session.force_clear_sessions
@@ -73,7 +73,7 @@ module IDRAC
               return false
             end
           else
-            puts "Auto-delete sessions is disabled or already tried clearing".light_yellow
+            puts "Already tried clearing sessions".light_yellow
             return false
           end
         else

data/lib/idrac.rb

@@ -36,6 +36,11 @@ module IDRAC
   def self.new(options = {})
     Client.new(options)
   end
+  
+  # Block-based API that ensures session cleanup
+  def self.connect(**options, &block)
+    Client.connect(**options, &block)
+  end
 end
 
 require 'idrac/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.7.9
 platform: ruby
 authors:
 - Jonathan Siegel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-22 00:00:00.000000000 Z
+date: 2025-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty