idrac 0.1.20 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87d81ae109224d8bfee1a4513bb10d307c703b74ab0d540a78aed849f16e26c4
-  data.tar.gz: 210a4e787490a16f76994090dc908248b97efec8f7bdb3c8a8136e6aee63ec5d
+  metadata.gz: 84cc513a711ebdea97f786857702ff36f607a0787e32dfe9b923f2587fc0f547
+  data.tar.gz: f6ff7e6b297064d268c702bbe89c7a6c663a9e0b7b4096bb92ae3ba922731e49
 SHA512:
-  metadata.gz: ea89b9514218b74a2393bc5eb46cc121a60ce9c6c9e0726f6c9df38b40dbb2cb5196bbc20350e56662729af77ef278dbabf6c4b61d162ac1a97467e3ef4fb548
-  data.tar.gz: a4213988f3a7ad827b20f90b8cdb4be43ffed7b20bc58f6dce3b9570b6504d73dfc34f67285f6cdd94515e0ec0a52651b27360c75464e297d0e0a448fbbf6774
+  metadata.gz: 40c1af62898da133ddb2ecf7dab1888c4b3b6758c7af912f9cdd3f2f644c089d42dea211c58a0aa5ceb056a04dec9df3cd98cdbe3b664c271aec3e4bc03f686a
+  data.tar.gz: b1977e34694d5a5c41d54fe461bcb8c03724e4bdf5a6c59aa08fd6325ddd22c41a50d0e615fbfba86428aaf73b6960f03f6dedf1a4811617d98aa466d04dbfa7

data/README.md

@@ -52,6 +52,20 @@ idrac firmware:interactive --host=192.168.1.100 --username=root --password=calvi
 
 All commands automatically handle session expiration by re-authenticating when necessary, ensuring that long-running operations like firmware updates complete successfully even if the iDRAC session times out.
 
+#### Session Management Options
+
+By default, the client will automatically delete existing sessions when the maximum session limit is reached. You can control this behavior with the `--auto-delete-sessions` option:
+
+```bash
+# Disable automatic session deletion (use direct mode instead when max sessions reached)
+idrac firmware:status --host=192.168.1.100 --no-auto-delete-sessions
+
+# Explicitly enable automatic session deletion (this is the default)
+idrac firmware:status --host=192.168.1.100 --auto-delete-sessions
+```
+
+When `--auto-delete-sessions` is enabled (the default), the client will attempt to delete existing sessions when it encounters a "maximum number of user sessions" error. When disabled, it will switch to direct mode (using Basic Authentication) instead of trying to clear sessions.
+
 ### Ruby API
 
 ```ruby
@@ -95,6 +109,14 @@ end
 # Update firmware
 job_id = firmware.update('/path/to/firmware.exe', wait: true)
 puts "Update completed with job ID: #{job_id}"
+
+# Create a client with auto_delete_sessions disabled
+client = IDRAC.new(
+  host: '192.168.1.100',
+  username: 'root',
+  password: 'calvin',
+  auto_delete_sessions: false
+)
 ```
 
 ## Development
@@ -105,6 +127,21 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Changelog
 
+### Version 0.1.22
+- **Session Management Control**: Added `--auto-delete-sessions` CLI option (default: true)
+- When enabled, the client automatically deletes existing sessions when maximum session limit is reached
+- When disabled, the client switches to direct mode instead of trying to clear sessions
+- Added detailed logging for session management decisions
+- Updated documentation with examples of how to use the new option
+
+### Version 0.1.21
+- **Improved Authentication Flow**: Completely restructured the login process
+- Renamed `legacy_login` to `webui_login` and limited its use to screenshot functionality only
+- Implemented proper Redfish authentication flow: start with direct login to get a session
+- Enhanced session management: when max sessions are encountered, delete sessions using direct login
+- Simplified code by removing redundant authentication methods and focusing on Redfish standards
+- Improved error handling and logging for better troubleshooting
+
 ### Version 0.1.20
 - **Simplified CLI Interface**: Removed the direct-mode CLI option
 - Maintained internal direct mode functionality as an automatic fallback mechanism

data/bin/idrac

@@ -19,6 +19,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 (default: true)"
 
     desc "firmware:update PATH", "Update firmware using the specified file"
     method_option :wait, type: :boolean, default: true, desc: "Wait for the update to complete"
@@ -191,7 +192,8 @@ module IDRAC
         password: options[:password],
         port: options[:port],
         use_ssl: !options[:no_ssl],
-        verify_ssl: options[:verify_ssl]
+        verify_ssl: options[:verify_ssl],
+        auto_delete_sessions: options[:auto_delete_sessions]
       )
     end
   end

data/lib/idrac/client.rb

@@ -8,10 +8,10 @@ require 'json'
 
 module IDRAC
   class Client
-    attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl
+    attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, :auto_delete_sessions
     attr_accessor :direct_mode
 
-    def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: true, direct_mode: false)
+    def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: true, direct_mode: false, auto_delete_sessions: true)
       @host = host
       @username = username
       @password = password
@@ -24,6 +24,7 @@ module IDRAC
       @direct_mode = direct_mode
       @sessions_maxed = false
       @tried_clearing_sessions = false
+      @auto_delete_sessions = auto_delete_sessions
     end
 
     def connection
@@ -34,58 +35,18 @@ module IDRAC
       end
     end
 
-    # Force clear all sessions by attempting multiple login/logout cycles
+    # Force clear all sessions by directly using Basic Auth
     def force_clear_sessions
       puts "Attempting to force clear all sessions..."
       
-      # First try to delete sessions directly using Basic Auth
+      # Try to delete sessions directly using Basic Auth
       if delete_all_sessions_with_basic_auth
         puts "Successfully cleared sessions using Basic Auth"
         return true
+      else
+        puts "Failed to clear sessions using Basic Auth"
+        return false
       end
-      
-      # If direct deletion fails, try the login/logout cycle approach
-      puts "Falling back to login/logout cycle approach for clearing sessions..."
-      
-      # Try multiple login/logout cycles with both methods
-      3.times do |i|
-        begin
-          # Try Redfish session first
-          begin
-            if create_redfish_session
-              puts "Successfully created Redfish session (attempt #{i+1})"
-              delete_redfish_session
-              puts "Deleted Redfish session (attempt #{i+1})"
-              sleep(2)
-            end
-          rescue => e
-            puts "Error during Redfish session cycle: #{e.message}"
-          end
-          
-          # Then try legacy session
-          begin
-            legacy_login(i)
-            puts "Successfully created legacy session (attempt #{i+1})"
-            legacy_logout
-            puts "Deleted legacy session (attempt #{i+1})"
-            sleep(2)
-          rescue => e
-            # If we get "maximum sessions" error, that's expected
-            if e.message.include?("maximum number of user sessions")
-              puts "Maximum sessions error during legacy login (expected during clearing)"
-            else
-              puts "Error during legacy session cycle: #{e.message}"
-            end
-          end
-          
-          # Add a longer delay between cycles
-          sleep(3) if i < 2
-        rescue => e
-          puts "Error during session clearing cycle #{i+1}: #{e.message}"
-        end
-      end
-      
-      puts "Completed session clearing attempts"
     end
 
     # Delete all sessions using Basic Authentication
@@ -158,19 +119,25 @@ module IDRAC
       end
     end
 
-    # Create a Redfish session (preferred method for all Redfish API calls)
+    # Create a Redfish session
     def create_redfish_session
-      # Skip if we're in direct mode or we know sessions are maxed out
-      if @direct_mode || @sessions_maxed
-        puts "Skipping Redfish session creation (direct mode or sessions maxed)"
+      # Skip if we're in direct mode
+      if @direct_mode
+        puts "Skipping Redfish session creation (direct mode)"
         return false
       end
       
       url = '/redfish/v1/SessionService/Sessions'
       payload = { "UserName" => username, "Password" => password }
       
+      # Use Basic Auth for the initial session creation
+      basic_auth_headers = {
+        'Authorization' => "Basic #{Base64.strict_encode64("#{username}:#{password}")}",
+        'Content-Type' => 'application/json'
+      }
+      
       response = connection.post(url) do |req|
-        req.headers['Content-Type'] = 'application/json'
+        req.headers.merge!(basic_auth_headers)
         req.body = payload.to_json
       end
       
@@ -188,31 +155,37 @@ module IDRAC
         puts "Maximum sessions reached during Redfish session creation"
         @sessions_maxed = true
         
-        # Only try to clear sessions if we haven't tried too many times
-        if !@tried_clearing_sessions
-          @tried_clearing_sessions = true
-          force_clear_sessions
-          
-          # Try one more time after clearing
-          response = connection.post(url) do |req|
-            req.headers['Content-Type'] = 'application/json'
-            req.body = payload.to_json
-          end
-          
-          if response.status == 201 || response.status == 200
-            @x_auth_token = response.headers['X-Auth-Token']
-            @session_location = response.headers['Location']
-            puts "Redfish session created successfully after clearing sessions"
-            @sessions_maxed = false
-            return true
+        # Try to clear sessions if auto_delete_sessions is enabled
+        if @auto_delete_sessions
+          puts "Auto-delete sessions is enabled, attempting to clear sessions"
+          if force_clear_sessions
+            puts "Successfully cleared sessions, trying to create a new session"
+            
+            # Try one more time after clearing
+            response = connection.post(url) do |req|
+              req.headers.merge!(basic_auth_headers)
+              req.body = payload.to_json
+            end
+            
+            if response.status == 201 || response.status == 200
+              @x_auth_token = response.headers['X-Auth-Token']
+              @session_location = response.headers['Location']
+              puts "Redfish session created successfully after clearing sessions"
+              @sessions_maxed = false
+              return true
+            else
+              puts "Failed to create Redfish session after clearing: #{response.status} - #{response.body}"
+              # If we still can't create a session, switch to direct mode
+              @direct_mode = true
+              return false
+            end
           else
-            puts "Failed to create Redfish session after clearing: #{response.status} - #{response.body}"
-            # If we still can't create a session, switch to direct mode
+            puts "Failed to clear sessions, switching to direct mode"
             @direct_mode = true
             return false
           end
         else
-          # If we've already tried clearing sessions, switch to direct mode
+          puts "Auto-delete sessions is disabled, switching to direct mode"
           @direct_mode = true
           return false
         end
@@ -244,24 +217,13 @@ module IDRAC
       end
     end
 
-    # Legacy login method for screenshot functionality
-    def legacy_login(retry_count = 0)
-      # Skip if we're in direct mode
-      if @direct_mode
-        puts "Skipping legacy login (direct mode)"
-        return false
-      end
-      
+    # WebUI login method for screenshot functionality only
+    def webui_login(retry_count = 0)
       # Limit retries to prevent infinite loops
       if retry_count >= 3
-        # If we've tried too many times, switch to direct mode
-        @direct_mode = true
-        raise Error, "Failed to login after multiple attempts due to maximum sessions limit"
+        raise Error, "Failed to login to WebUI after multiple attempts"
       end
       
-      # Always try to logout first to clear any existing sessions
-      legacy_logout if retry_count > 0
-      
       response = connection.post('/data/login') do |req|
         req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
         req.body = "user=#{username}&password=#{password}"
@@ -282,13 +244,17 @@ module IDRAC
         if error_message && !error_message.empty?
           # Check for maximum sessions error
           if error_message.include?("maximum number of user sessions")
-            puts "Maximum sessions reached, attempting to clear sessions (attempt #{retry_count + 1}/3)..."
-            # Try to clear any existing sessions by forcing a logout
-            legacy_logout
-            # Wait longer for the server to process the logout
-            sleep(5)
-            # Try logging in again with incremented retry counter
-            return legacy_login(retry_count + 1)
+            puts "Maximum sessions reached for WebUI, attempting to clear sessions (attempt #{retry_count + 1}/3)..."
+            # Try to clear any existing sessions if auto_delete_sessions is enabled
+            if @auto_delete_sessions
+              force_clear_sessions
+              # Wait for the server to process the session changes
+              sleep(3)
+              # Try logging in again with incremented retry counter
+              return webui_login(retry_count + 1)
+            else
+              raise Error, "Maximum sessions reached and auto-delete sessions is disabled"
+            end
           end
           
           raise Error, "Error Message: #{error_message}"
@@ -297,27 +263,21 @@ module IDRAC
         forward_url = xml_doc.xpath('//forwardUrl').text
         return forward_url
       else
-        raise Error, "Login failed with status #{response.status}: #{response.body}"
+        raise Error, "WebUI login failed with status #{response.status}: #{response.body}"
       end
     end
 
-    # Legacy logout method for screenshot functionality
-    def legacy_logout
+    # WebUI logout method for screenshot functionality
+    def webui_logout
       return unless @session_id
       
       begin
-        # Try multiple logout attempts to ensure session is cleared
-        3.times do |i|
-          response = connection.get('/data/logout') do |req|
-            req.headers['Cookie'] = "sessionid=#{@session_id}"
-          end
-          
-          break if response.status == 200
-          sleep(1) if i < 2  # Sleep between attempts, but not after the last one
+        response = connection.get('/data/logout') do |req|
+          req.headers['Cookie'] = "sessionid=#{@session_id}"
         end
       rescue => e
         # Ignore errors during logout
-        puts "Warning: Error during logout: #{e.message}"
+        puts "Warning: Error during WebUI logout: #{e.message}"
       ensure
         @session_id = nil
         @cookies = nil
@@ -326,7 +286,7 @@ module IDRAC
       true
     end
 
-    # Main login method that decides which approach to use
+    # Main login method
     def login
       # If we're in direct mode, skip login attempts
       if @direct_mode
@@ -334,40 +294,29 @@ module IDRAC
         return true
       end
       
-      # First try to create a Redfish session
+      # Try to create a Redfish session
       if create_redfish_session
         return true
       else
-        # If we failed to create a Redfish session, try to clear sessions first
-        if !@tried_clearing_sessions
-          @tried_clearing_sessions = true
-          force_clear_sessions
-          
-          # Try Redfish again
-          if create_redfish_session
-            return true
-          end
-        end
-        
-        # Fall back to legacy login if Redfish session creation fails
-        if !@direct_mode
-          puts "Falling back to legacy login method"
-          return legacy_login
-        else
+        # If we failed to create a Redfish session and direct_mode is set, just return
+        if @direct_mode
           puts "Operating in direct mode (no session)"
           return true
+        else
+          # If we're here, something went wrong with session creation
+          raise Error, "Failed to create a session and direct mode is not enabled"
         end
       end
     end
 
-    # Main logout method that decides which approach to use
+    # Main logout method
     def logout
       if @x_auth_token
         delete_redfish_session
       end
       
       if @session_id
-        legacy_logout
+        webui_logout
       end
       
       true
@@ -384,23 +333,15 @@ module IDRAC
       # Ensure we have a valid session (unless in direct mode)
       unless @direct_mode
         begin
-          login unless @x_auth_token || @session_id
+          login unless @x_auth_token
         rescue Error => e
-          # If login fails with maximum sessions error, try to handle it
-          if e.message.include?("maximum number of user sessions") && retry_count < 2
-            puts "Maximum sessions reached during initial login, attempting to clear sessions (attempt #{retry_count + 1}/3)..."
-            logout
-            sleep(5)  # Longer delay
-            return authenticated_request(method, path, options, retry_count + 1)
+          # If login fails and we've tried too many times, switch to direct mode
+          if retry_count >= 2
+            @direct_mode = true
+            puts "Switching to direct mode after multiple authentication failures"
           else
-            # If we've tried too many times, switch to direct mode
-            if retry_count >= 2
-              @direct_mode = true
-              puts "Switching to direct mode after multiple authentication failures"
-            else
-              # Re-raise other errors or if we've tried too many times
-              raise
-            end
+            # Re-raise other errors
+            raise
           end
         end
       end
@@ -410,9 +351,6 @@ module IDRAC
       # Use X-Auth-Token if available (preferred Redfish method)
       if @x_auth_token
         options[:headers]['X-Auth-Token'] = @x_auth_token
-      elsif @session_id
-        # Fall back to session cookie if needed
-        options[:headers]['Cookie'] = "sessionid=#{@session_id}"
       elsif @direct_mode
         # In direct mode, use Basic Auth
         options[:headers]['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
@@ -427,15 +365,13 @@ module IDRAC
       if response.status == 401 && !@direct_mode
         puts "Session expired, re-authenticating..."
         logout
-        sleep(3)
+        sleep(2)
         login
         
         # Update headers with new authentication
         options[:headers] ||= {}
         if @x_auth_token
           options[:headers]['X-Auth-Token'] = @x_auth_token
-        elsif @session_id
-          options[:headers]['Cookie'] = "sessionid=#{@session_id}"
         elsif @direct_mode
           options[:headers]['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
         end
@@ -453,31 +389,13 @@ module IDRAC
         end
       end
       
-      # Check for maximum sessions error in the response
-      if response.status == 200
-        begin
-          xml_doc = Nokogiri::XML(response.body)
-          error_message = xml_doc.at_xpath('//errorMsg')&.text
-          
-          if error_message && error_message.include?("maximum number of user sessions") && retry_count < 2
-            puts "Maximum sessions reached, clearing sessions and retrying (attempt #{retry_count + 1}/3)..."
-            logout
-            sleep(5)
-            login
-            return authenticated_request(method, path, options, retry_count + 1)
-          end
-        rescue => e
-          # If we can't parse the response as XML, just continue
-        end
-      end
-      
       response
     end
 
     def get(path:, headers: {})
-      # For screenshot functionality, we need to use the legacy cookies
-      if @cookies.nil? && !@direct_mode
-        legacy_login unless @session_id
+      # For screenshot functionality, we need to use the WebUI cookies
+      if @cookies.nil? && path.include?('screen/screen.jpg')
+        webui_login unless @session_id
       end
       
       headers_to_use = {
@@ -490,6 +408,8 @@ module IDRAC
       elsif @direct_mode
         # In direct mode, use Basic Auth
         headers_to_use["Authorization"] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
+      elsif @x_auth_token
+        headers_to_use["X-Auth-Token"] = @x_auth_token
       end
       
       response = HTTParty.get(

data/lib/idrac/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.1.20
+  version: 0.1.22
 platform: ruby
 authors:
 - Jonathan Siegel