idrac 0.1.38 → 0.1.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 462eec3a8d4efc8ef0c8b79247cb3b5624f96c97b1cb2b98e10311939fcea521
-  data.tar.gz: 91793e111a24c4d71ef4ab9c38ea6291630b4314e754f108068a6cded9c23b70
+  metadata.gz: 822357c4c005e77d857696867b06be46e3f1f473a239e2936119aec1e68c5eb9
+  data.tar.gz: 6ca9c128259d2d94518b2b22ee0d8bfff02624a8f8b15fbabd816a2e08351f8f
 SHA512:
-  metadata.gz: 0e6ecd835d5f68d3e4230944843131d70cc5e239bfc546127af7fed5d9fe83a82c4c5421f68fd88ea76f6f94fc9df8193405c936f20ee1a4905cc66e3d457bd7
-  data.tar.gz: e301acc6c69c352fb3ae4bc2503a7501ab01fe4dd3af9597a2b276aa468c98cb9a9e03c649e55271b26edc8d738b7fcf758e46ab5adef4100cbd6553583f1371
+  metadata.gz: a50e1c605aaaa5c4cfe72a49a60d41c63765c20e6bfc3d7d43063a0e53cd29804797094e38287e63ee3cddbcd1335ba543417ec75f089541a950ef55654042df
+  data.tar.gz: d3306667a4271507a7923a95b78b557ca55abe78900fee320c36bfb98eda0cafbd268afaaa4bf4fee4a2241b344b634ce445900bae9a768132862995553dd813

data/README.md

@@ -92,15 +92,10 @@ client = IDRAC.new(
 # The client automatically handles session expiration (401 errors)
 # by re-authenticating and retrying the request
 
-# Take a screenshot (using the client convenience method)
+# Take a screenshot (using the client method)
 filename = client.screenshot
 puts "Screenshot saved to: #{filename}"
 
-# Or use the Screenshot class directly for more control
-screenshot = IDRAC::Screenshot.new(client)
-filename = screenshot.capture
-puts "Screenshot saved to: #{filename}"
-
 # Firmware operations
 firmware = IDRAC::Firmware.new(client)
 

data/bin/idrac

@@ -185,9 +185,8 @@ module IDRAC
       client = create_client
       
       begin
-        # Create a Screenshot instance directly
-        screenshot = IDRAC::Screenshot.new(client)
-        filename = screenshot.capture
+        # Capture a screenshot using the client
+        filename = client.screenshot
         
         # Rename the file if output option is provided
         if options[:output]

data/lib/idrac/client.rb

@@ -9,7 +9,7 @@ require 'colorize'
 
 module IDRAC
   class Client
-    attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, :auto_delete_sessions
+    attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, :auto_delete_sessions, :session, :web
     attr_accessor :direct_mode
 
     def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: true, direct_mode: false, auto_delete_sessions: true)
@@ -19,13 +19,12 @@ module IDRAC
       @port = port
       @use_ssl = use_ssl
       @verify_ssl = verify_ssl
-      @session_id = nil
-      @cookies = nil
-      @x_auth_token = nil
       @direct_mode = direct_mode
-      @sessions_maxed = false
-      @tried_clearing_sessions = false
       @auto_delete_sessions = auto_delete_sessions
+      
+      # Initialize the session and web classes
+      @session = Session.new(self)
+      @web = Web.new(self)
     end
 
     def connection
@@ -36,353 +35,6 @@ module IDRAC
       end
     end
 
-    # Force clear all sessions by directly using Basic Auth
-    def force_clear_sessions
-      puts "Attempting to force clear all sessions...".light_cyan
-      
-      # Try to delete sessions directly using Basic Auth
-      if delete_all_sessions_with_basic_auth
-        puts "Successfully cleared sessions using Basic Auth".green
-        return true
-      else
-        puts "Failed to clear sessions using Basic Auth".red
-        return false
-      end
-    end
-
-    # Delete all sessions using Basic Authentication
-    def delete_all_sessions_with_basic_auth
-      puts "Attempting to delete all sessions using Basic Authentication...".light_cyan
-      
-      # First, get the list of sessions
-      sessions_url = '/redfish/v1/SessionService/Sessions'
-      
-      # Create a connection with Basic Auth
-      basic_auth_headers = {
-        'Authorization' => "Basic #{Base64.strict_encode64("#{username}:#{password}")}",
-        'Content-Type' => 'application/json'
-      }
-      
-      begin
-        # Get the list of sessions
-        response = connection.get(sessions_url) do |req|
-          req.headers.merge!(basic_auth_headers)
-        end
-        
-        if response.status != 200
-          puts "Failed to get sessions list: #{response.status} - #{response.body}".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?
-            puts "Found #{sessions_data['Members'].count} active sessions".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 = connection.delete(session_url) do |req|
-                req.headers.merge!(basic_auth_headers)
-              end
-              
-              if delete_response.status == 200 || delete_response.status == 204
-                puts "Successfully deleted session: #{session_url}".green
-              else
-                puts "Failed to delete session #{session_url}: #{delete_response.status}".red
-                success = false
-              end
-              
-              # Small delay between deletions
-              sleep(1)
-            end
-            
-            return success
-          else
-            puts "No active sessions found".light_yellow
-            return true
-          end
-        rescue JSON::ParserError => e
-          puts "Error parsing sessions response: #{e.message}".red.bold
-          return false
-        end
-      rescue => e
-        puts "Error during session deletion with Basic Auth: #{e.message}".red.bold
-        return false
-      end
-    end
-
-    # Create a Redfish session
-    def create_redfish_session
-      # Skip if we're in direct mode
-      if @direct_mode
-        puts "Skipping Redfish session creation (direct mode)".light_yellow
-        return false
-      end
-      
-      url = '/redfish/v1/SessionService/Sessions'
-      payload = { "UserName" => username, "Password" => password }
-      
-      # Try first with just Content-Type header (no Basic Auth)
-      begin
-        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
-          # Extract X-Auth-Token from response headers
-          @x_auth_token = response.headers['X-Auth-Token']
-          
-          # Extract session location from response headers
-          @session_location = response.headers['Location']
-          
-          puts "Redfish session created successfully".green
-          @sessions_maxed = false
-          return true
-        end
-      rescue => e
-        puts "First session creation attempt failed: #{e.message}".light_red
-      end
-      
-      # If that fails, try with Basic Auth
-      begin
-        # Use Basic Auth for the session creation
-        basic_auth_headers = {
-          'Authorization' => "Basic #{Base64.strict_encode64("#{username}:#{password}")}",
-          'Content-Type' => 'application/json'
-        }
-        
-        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
-          # Extract X-Auth-Token from response headers
-          @x_auth_token = response.headers['X-Auth-Token']
-          
-          # Extract session location from response headers
-          @session_location = response.headers['Location']
-          
-          puts "Redfish session created successfully with Basic Auth".green
-          @sessions_maxed = false
-          return true
-        elsif response.status == 400 && response.body.include?("maximum number of user sessions")
-          puts "Maximum sessions reached during Redfish session creation".light_red
-          @sessions_maxed = 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".light_cyan
-            if force_clear_sessions
-              puts "Successfully cleared sessions, trying to create a new session".green
-              
-              # 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".green
-                @sessions_maxed = false
-                return true
-              else
-                puts "Failed to create Redfish session after clearing: #{response.status} - #{response.body}".red
-                # If we still can't create a session, switch to direct mode
-                @direct_mode = true
-                return false
-              end
-            else
-              puts "Failed to clear sessions, switching to direct mode".light_yellow
-              @direct_mode = true
-              return false
-            end
-          else
-            puts "Auto-delete sessions is disabled, switching to direct mode".light_yellow
-            @direct_mode = true
-            return false
-          end
-        else
-          puts "Failed to create Redfish session: #{response.status} - #{response.body}".red
-          
-          # If we get a 415 error, try with form-urlencoded
-          if response.status == 415
-            puts "Trying with form-urlencoded content type".light_cyan
-            response = connection.post(url) do |req|
-              req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
-              req.headers['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
-              req.body = "UserName=#{URI.encode_www_form_component(username)}&Password=#{URI.encode_www_form_component(password)}"
-            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 with form-urlencoded".green
-              @sessions_maxed = false
-              return true
-            else
-              puts "Failed with form-urlencoded too: #{response.status} - #{response.body}".red
-              @direct_mode = true
-              return false
-            end
-          else
-            @direct_mode = true
-            return false
-          end
-        end
-      rescue => e
-        puts "Error during Redfish session creation: #{e.message}".red.bold
-        @direct_mode = true
-        return false
-      end
-    end
-    
-    # Delete the Redfish session
-    def delete_redfish_session
-      return unless @x_auth_token && @session_location
-      
-      begin
-        puts "Deleting Redfish session...".light_cyan
-        
-        # Use the X-Auth-Token for authentication
-        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
-          puts "Redfish session deleted successfully".green
-          @x_auth_token = nil
-          @session_location = nil
-          return true
-        else
-          puts "Failed to delete Redfish session: #{response.status} - #{response.body}".red
-          return false
-        end
-      rescue => e
-        puts "Error during Redfish session deletion: #{e.message}".red.bold
-        return false
-      end
-    end
-
-    # Login to the WebUI (for screenshot functionality)
-    def webui_login(retry_count = 0)
-      # Limit retries to prevent infinite loops
-      if retry_count >= 3
-        puts "Maximum retry count reached for WebUI login".red
-        return false
-      end
-      
-      # Skip if we already have a session ID
-      return true if @session_id
-      
-      begin
-        puts "Logging in to WebUI...".light_cyan
-        
-        # Create the login URL
-        login_url = "#{base_url}/data/login"
-        
-        # Create the login payload
-        payload = {
-          'user' => username,
-          'password' => password
-        }
-        
-        # Make the login request
-        response = HTTParty.post(
-          login_url,
-          body: payload,
-          verify: verify_ssl,
-          headers: { 'Content-Type' => 'application/x-www-form-urlencoded' }
-        )
-        
-        # Check if the login was successful
-        if response.code == 200
-          # Extract the session ID from the response
-          if response.body.include?('ST2')
-            @session_id = response.body.match(/ST2=([^;]+)/)[1]
-            @cookies = response.headers['set-cookie']
-            puts "WebUI login successful".green
-            return true
-          else
-            puts "WebUI login failed: No session ID found in response".red
-            return false
-          end
-        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 @auto_delete_sessions && !@tried_clearing_sessions
-            puts "Auto-delete sessions is enabled, attempting to clear sessions".light_cyan
-            @tried_clearing_sessions = true
-            
-            if force_clear_sessions
-              puts "Successfully cleared sessions, trying WebUI login again".green
-              return webui_login(retry_count + 1)
-            else
-              puts "Failed to clear sessions for WebUI login".red
-              return false
-            end
-          else
-            puts "Auto-delete sessions is disabled or already tried clearing".light_yellow
-            return false
-          end
-        else
-          puts "WebUI login failed: #{response.code} - #{response.body}".red
-          return false
-        end
-      rescue => e
-        puts "Error during WebUI login: #{e.message}".red.bold
-        return false
-      end
-    end
-
-    # Logout from the WebUI
-    def webui_logout
-      return unless @session_id
-      
-      begin
-        puts "Logging out from WebUI...".light_cyan
-        
-        # Create the logout URL
-        logout_url = "#{base_url}/data/logout"
-        
-        # Make the logout request
-        response = HTTParty.get(
-          logout_url,
-          verify: verify_ssl,
-          headers: { 'Cookie' => @cookies }
-        )
-        
-        # Check if the logout was successful
-        if response.code == 200
-          puts "WebUI logout successful".green
-          @session_id = nil
-          @cookies = nil
-          return true
-        else
-          puts "WebUI logout failed: #{response.code} - #{response.body}".red
-          return false
-        end
-      rescue => e
-        puts "Error during WebUI logout: #{e.message}".red.bold
-        return false
-      end
-    end
-
     # Login to iDRAC
     def login
       # If we're in direct mode, skip login attempts
@@ -392,16 +44,11 @@ module IDRAC
       end
       
       # Try to create a Redfish session
-      if create_redfish_session
+      if session.create
         puts "Successfully logged in to iDRAC using Redfish session".green
         return true
       else
-        if @sessions_maxed
-          puts "Maximum sessions reached and could not clear sessions".light_red
-        else
-          puts "Failed to create Redfish session, falling back to direct mode".light_yellow
-        end
-        
+        puts "Failed to create Redfish session, falling back to direct mode".light_yellow
         @direct_mode = true
         return true
       end
@@ -409,14 +56,8 @@ module IDRAC
 
     # Logout from iDRAC
     def logout
-      if @x_auth_token
-        delete_redfish_session
-      end
-      
-      if @session_id
-        webui_logout
-      end
-      
+      session.delete if session.x_auth_token
+      web.logout if web.session_id
       puts "Logged out from iDRAC".green
       return true
     end
@@ -452,10 +93,10 @@ module IDRAC
         end
       else
         # Use X-Auth-Token if available
-        if @x_auth_token
+        if session.x_auth_token
           # Add the X-Auth-Token header to the request
           options[:headers] ||= {}
-          options[:headers]['X-Auth-Token'] = @x_auth_token
+          options[:headers]['X-Auth-Token'] = session.x_auth_token
           
           # Make the request
           begin
@@ -469,7 +110,7 @@ module IDRAC
               puts "Session expired or invalid, attempting to create a new session...".light_yellow
               
               # Try to create a new session
-              if create_redfish_session
+              if session.create
                 puts "Successfully created a new session, retrying request...".green
                 return authenticated_request(method, path, options, retry_count + 1)
               else
@@ -484,7 +125,7 @@ module IDRAC
             puts "Error during authenticated request (token mode): #{e.message}".red.bold
             
             # Try to create a new session
-            if create_redfish_session
+            if session.create
               puts "Successfully created a new session after error, retrying request...".green
               return authenticated_request(method, path, options, retry_count + 1)
             else
@@ -495,7 +136,7 @@ module IDRAC
           end
         else
           # If we don't have a token, try to create a session
-          if create_redfish_session
+          if session.create
             puts "Successfully created a new session, making request...".green
             return authenticated_request(method, path, options, retry_count + 1)
           else
@@ -509,8 +150,8 @@ module IDRAC
 
     def get(path:, headers: {})
       # For screenshot functionality, we need to use the WebUI cookies
-      if @cookies.nil? && path.include?('screen/screen.jpg')
-        webui_login unless @session_id
+      if web.cookies.nil? && path.include?('screen/screen.jpg')
+        web.login unless web.session_id
       end
       
       headers_to_use = {
@@ -518,16 +159,16 @@ module IDRAC
         "Accept-Encoding" => "deflate, gzip"
       }
       
-      if @cookies
-        headers_to_use["Cookie"] = @cookies
+      if web.cookies
+        headers_to_use["Cookie"] = web.cookies
       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
+      elsif session.x_auth_token
+        headers_to_use["X-Auth-Token"] = session.x_auth_token
       end
       
-      response = HTTParty.get(
+      HTTParty.get(
         "#{base_url}/#{path}",
         headers: headers_to_use.merge(headers),
         verify: false
@@ -535,9 +176,7 @@ module IDRAC
     end
 
     def screenshot
-      # Create a Screenshot instance and capture a screenshot
-      screenshot_instance = Screenshot.new(self)
-      screenshot_instance.capture
+      web.capture_screenshot
     end
 
     def base_url

data/lib/idrac/session.rb

@@ -0,0 +1,278 @@
+require 'faraday'
+require 'base64'
+require 'json'
+require 'colorize'
+require 'uri'
+
+module IDRAC
+  class Session
+    attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, 
+                :x_auth_token, :session_location, :direct_mode, :auto_delete_sessions
+
+    def initialize(client)
+      @client = client
+      @host = client.host
+      @username = client.username
+      @password = client.password
+      @port = client.port
+      @use_ssl = client.use_ssl
+      @verify_ssl = client.verify_ssl
+      @x_auth_token = nil
+      @session_location = nil
+      @direct_mode = client.direct_mode
+      @sessions_maxed = false
+      @auto_delete_sessions = client.auto_delete_sessions
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: base_url, ssl: { verify: verify_ssl }) do |faraday|
+        faraday.request :multipart
+        faraday.request :url_encoded
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    # Force clear all sessions by directly using Basic Auth
+    def force_clear_sessions
+      puts "Attempting to force clear all sessions...".light_cyan
+      
+      if delete_all_sessions_with_basic_auth
+        puts "Successfully cleared sessions using Basic Auth".green
+        true
+      else
+        puts "Failed to clear sessions using Basic Auth".red
+        false
+      end
+    end
+
+    # Delete all sessions using Basic Authentication
+    def delete_all_sessions_with_basic_auth
+      puts "Attempting to delete all sessions using Basic Authentication...".light_cyan
+      
+      # First, get the list of sessions
+      sessions_url = '/redfish/v1/SessionService/Sessions'
+      
+      begin
+        # Get the list of sessions
+        response = request_with_basic_auth(:get, sessions_url)
+        
+        if response.status != 200
+          puts "Failed to get sessions list: #{response.status} - #{response.body}".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?
+            puts "Found #{sessions_data['Members'].count} active sessions".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 = request_with_basic_auth(:delete, session_url)
+              
+              if delete_response.status == 200 || delete_response.status == 204
+                puts "Successfully deleted session: #{session_url}".green
+              else
+                puts "Failed to delete session #{session_url}: #{delete_response.status}".red
+                success = false
+              end
+              
+              # Small delay between deletions
+              sleep(1)
+            end
+            
+            return success
+          else
+            puts "No active sessions found".light_yellow
+            return true
+          end
+        rescue JSON::ParserError => e
+          puts "Error parsing sessions response: #{e.message}".red.bold
+          return false
+        end
+      rescue => e
+        puts "Error during session deletion with Basic Auth: #{e.message}".red.bold
+        return false
+      end
+    end
+
+    # Create a Redfish session
+    def create
+      # Skip if we're in direct mode
+      if @direct_mode
+        puts "Skipping Redfish session creation (direct mode)".light_yellow
+        return false
+      end
+      
+      url = '/redfish/v1/SessionService/Sessions'
+      payload = { "UserName" => username, "Password" => password }
+      
+      # Try creation methods in sequence
+      return true if create_session_with_content_type(url, payload)
+      return true if create_session_with_basic_auth(url, payload)
+      return true if handle_max_sessions_and_retry(url, payload)
+      return true if create_session_with_form_urlencoded(url, payload)
+      
+      # If all attempts fail, switch to direct mode
+      @direct_mode = true
+      false
+    end
+    
+    # Delete the Redfish session
+    def delete
+      return unless @x_auth_token && @session_location
+      
+      begin
+        puts "Deleting Redfish session...".light_cyan
+        
+        # Use the X-Auth-Token for authentication
+        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
+          puts "Redfish session deleted successfully".green
+          @x_auth_token = nil
+          @session_location = nil
+          return true
+        else
+          puts "Failed to delete Redfish session: #{response.status} - #{response.body}".red
+          return false
+        end
+      rescue => e
+        puts "Error during Redfish session deletion: #{e.message}".red.bold
+        return false
+      end
+    end
+
+    private
+
+    def base_url
+      protocol = use_ssl ? 'https' : 'http'
+      "#{protocol}://#{host}:#{port}"
+    end
+    
+    def basic_auth_headers
+      {
+        'Authorization' => "Basic #{Base64.strict_encode64("#{username}:#{password}")}",
+        'Content-Type' => 'application/json'
+      }
+    end
+    
+    def request_with_basic_auth(method, url, body = nil)
+      connection.send(method, url) do |req|
+        req.headers.merge!(basic_auth_headers)
+        req.body = body if body
+      end
+    rescue => e
+      puts "Error during #{method} request with Basic Auth: #{e.message}".red.bold
+      raise e
+    end
+    
+    def process_session_response(response)
+      if response.status == 201 || response.status == 200
+        @x_auth_token = response.headers['X-Auth-Token']
+        @session_location = response.headers['Location']
+        @sessions_maxed = false
+        true
+      else
+        false
+      end
+    end
+    
+    def create_session_with_content_type(url, payload)
+      begin
+        response = connection.post(url) do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.body = payload.to_json
+        end
+        
+        if process_session_response(response)
+          puts "Redfish session created successfully".green
+          return true
+        end
+      rescue => e
+        puts "First session creation attempt failed: #{e.message}".light_red
+      end
+      false
+    end
+    
+    def create_session_with_basic_auth(url, payload)
+      begin
+        response = request_with_basic_auth(:post, url, payload.to_json)
+        
+        if process_session_response(response)
+          puts "Redfish session created successfully with Basic Auth".green
+          return true
+        elsif response.status == 400 && response.body.include?("maximum number of user sessions")
+          puts "Maximum sessions reached during Redfish session creation".light_red
+          @sessions_maxed = true
+          return false
+        else
+          puts "Failed to create Redfish session: #{response.status} - #{response.body}".red
+          return false
+        end
+      rescue => e
+        puts "Error during Redfish session creation with Basic Auth: #{e.message}".red.bold
+        return false
+      end
+    end
+    
+    def handle_max_sessions_and_retry(url, payload)
+      return false unless @sessions_maxed && @auto_delete_sessions
+      
+      puts "Auto-delete sessions is enabled, attempting to clear sessions".light_cyan
+      if force_clear_sessions
+        puts "Successfully cleared sessions, trying to create a new session".green
+        
+        # Try one more time after clearing
+        response = request_with_basic_auth(:post, url, payload.to_json)
+        
+        if process_session_response(response)
+          puts "Redfish session created successfully after clearing sessions".green
+          return true
+        else
+          puts "Failed to create Redfish session after clearing sessions: #{response.status} - #{response.body}".red
+          return false
+        end
+      else
+        puts "Failed to clear sessions, switching to direct mode".light_yellow
+        return false
+      end
+    end
+    
+    def create_session_with_form_urlencoded(url, payload)
+      # Only try with form-urlencoded if we had a 415 error previously
+      begin
+        puts "Trying with form-urlencoded content type".light_cyan
+        response = connection.post(url) do |req|
+          req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+          req.headers['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
+          req.body = "UserName=#{URI.encode_www_form_component(username)}&Password=#{URI.encode_www_form_component(password)}"
+        end
+        
+        if process_session_response(response)
+          puts "Redfish session created successfully with form-urlencoded".green
+          return true
+        else
+          puts "Failed with form-urlencoded too: #{response.status} - #{response.body}".red
+          return false
+        end
+      rescue => e
+        puts "Error during form-urlencoded session creation: #{e.message}".red.bold
+        return false
+      end
+    end
+  end
+end 

data/lib/idrac/version.rb

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

data/lib/idrac/web.rb

@@ -0,0 +1,187 @@
+require 'httparty'
+require 'nokogiri'
+require 'uri'
+require 'colorize'
+
+module IDRAC
+  class Web
+    attr_reader :client, :session_id, :cookies
+
+    def initialize(client)
+      @client = client
+      @session_id = nil
+      @cookies = nil
+      @tried_clearing_sessions = false
+    end
+
+    # Login to the WebUI
+    def login(retry_count = 0)
+      # Limit retries to prevent infinite loops
+      if retry_count >= 3
+        puts "Maximum retry count reached for WebUI login".red
+        return false
+      end
+      
+      # Skip if we already have a session ID
+      return true if @session_id
+      
+      begin
+        puts "Logging in to WebUI...".light_cyan
+        
+        # Create the login URL
+        login_url = "#{base_url}/data/login"
+        
+        # Create the login payload
+        payload = {
+          'user' => client.username,
+          'password' => client.password
+        }
+        
+        # Make the login request
+        response = HTTParty.post(
+          login_url,
+          body: payload,
+          verify: client.verify_ssl,
+          headers: { 'Content-Type' => 'application/x-www-form-urlencoded' }
+        )
+        
+        # Check if the login was successful
+        if response.code == 200
+          # Extract the session ID from the response
+          if response.body.include?('ST2')
+            @session_id = response.body.match(/ST2=([^;]+)/)[1]
+            @cookies = response.headers['set-cookie']
+            puts "WebUI login successful".green
+            return response.body
+          else
+            puts "WebUI login failed: No session ID found in response".red
+            return false
+          end
+        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
+            @tried_clearing_sessions = true
+            
+            if client.session.force_clear_sessions
+              puts "Successfully cleared sessions, trying WebUI login again".green
+              return login(retry_count + 1)
+            else
+              puts "Failed to clear sessions for WebUI login".red
+              return false
+            end
+          else
+            puts "Auto-delete sessions is disabled or already tried clearing".light_yellow
+            return false
+          end
+        else
+          puts "WebUI login failed: #{response.code} - #{response.body}".red
+          return false
+        end
+      rescue => e
+        puts "Error during WebUI login: #{e.message}".red.bold
+        return false
+      end
+    end
+
+    # Logout from the WebUI
+    def logout
+      return unless @session_id
+      
+      begin
+        puts "Logging out from WebUI...".light_cyan
+        
+        # Create the logout URL
+        logout_url = "#{base_url}/data/logout"
+        
+        # Make the logout request
+        response = HTTParty.get(
+          logout_url,
+          verify: client.verify_ssl,
+          headers: { 'Cookie' => @cookies }
+        )
+        
+        # Check if the logout was successful
+        if response.code == 200
+          puts "WebUI logout successful".green
+          @session_id = nil
+          @cookies = nil
+          return true
+        else
+          puts "WebUI logout failed: #{response.code} - #{response.body}".red
+          return false
+        end
+      rescue => e
+        puts "Error during WebUI logout: #{e.message}".red.bold
+        return false
+      end
+    end
+
+    # Capture a screenshot
+    def capture_screenshot
+      # Login to get the forward URL and cookies
+      forward_url = login
+      return nil unless forward_url
+      
+      # Extract the key-value pairs from the forward URL (format: index?ST1=ABC,ST2=DEF)
+      tokens = forward_url.split("?").last.split(",").inject({}) do |acc, kv| 
+        k, v = kv.split("=")
+        acc[k] = v
+        acc
+      end
+      
+      # Generate a timestamp for the request
+      timestamp_ms = (Time.now.to_f * 1000).to_i
+      
+      # First request to trigger the screenshot capture
+      path = "data?get=consolepreview[manual%20#{timestamp_ms}]"
+      res = get(path: path, headers: tokens)
+      raise Error, "Failed to trigger screenshot capture." unless res.code.between?(200, 299)
+      
+      # Wait for the screenshot to be generated
+      sleep 2
+      
+      # Second request to get the actual screenshot image
+      path = "capconsole/scapture0.png?#{timestamp_ms}"
+      res = get(path: path, headers: tokens)
+      raise Error, "Failed to retrieve screenshot image." unless res.code.between?(200, 299)
+      
+      # Save the screenshot to a file
+      filename = "idrac_screenshot_#{timestamp_ms}.png"
+      File.open(filename, "wb") { |f| f.write(res.body) }
+      
+      # Return the filename
+      filename
+    end
+
+    # HTTP GET request for WebUI operations
+    def get(path:, headers: {})
+      headers_to_use = {
+        "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36",
+        "Accept-Encoding" => "deflate, gzip"
+      }
+      
+      if @cookies
+        headers_to_use["Cookie"] = @cookies
+      elsif client.direct_mode
+        # In direct mode, use Basic Auth
+        headers_to_use["Authorization"] = "Basic #{Base64.strict_encode64("#{client.username}:#{client.password}")}"
+      end
+      
+      HTTParty.get(
+        "#{base_url}/#{path}",
+        headers: headers_to_use.merge(headers),
+        verify: false
+      )
+    end
+
+    private
+
+    def base_url
+      protocol = client.use_ssl ? 'https' : 'http'
+      "#{protocol}://#{client.host}:#{client.port}"
+    end
+  end
+end 

data/lib/idrac.rb

@@ -12,8 +12,9 @@ require 'debug' if ENV['RUBY_ENV'] == 'development'
 
 require_relative "idrac/version"
 require_relative "idrac/error"
+require_relative "idrac/session"
+require_relative "idrac/web"
 require_relative "idrac/client"
-require_relative "idrac/screenshot"
 require_relative "idrac/firmware"
 require_relative "idrac/firmware_catalog"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.1.38
+  version: 0.1.40
 platform: ruby
 authors:
 - Jonathan Siegel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-02 00:00:00.000000000 Z
+date: 2025-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -224,8 +224,9 @@ files:
 - lib/idrac/error.rb
 - lib/idrac/firmware.rb
 - lib/idrac/firmware_catalog.rb
-- lib/idrac/screenshot.rb
+- lib/idrac/session.rb
 - lib/idrac/version.rb
+- lib/idrac/web.rb
 homepage: http://github.com
 licenses:
 - MIT
@@ -246,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: API Client for Dell iDRAC

data/lib/idrac/screenshot.rb

@@ -1,49 +0,0 @@
-require 'httparty'
-require 'nokogiri'
-
-module IDRAC
-  # Reverse engineered screenshot functionality for iDRAC
-  # This uses introspection on how the web UI creates screenshots rather than the Redfish API
-  class Screenshot
-    attr_reader :client
-
-    def initialize(client)
-      @client = client
-    end
-
-    def capture
-      # Login to get the forward URL and cookies
-      forward_url = client.login
-      
-      # Extract the key-value pairs from the forward URL (format: index?ST1=ABC,ST2=DEF)
-      tokens = forward_url.split("?").last.split(",").inject({}) do |acc, kv| 
-        k, v = kv.split("=")
-        acc[k] = v
-        acc
-      end
-      
-      # Generate a timestamp for the request
-      timestamp_ms = (Time.now.to_f * 1000).to_i
-      
-      # First request to trigger the screenshot capture
-      path = "data?get=consolepreview[manual%20#{timestamp_ms}]"
-      res = client.get(path: path, headers: tokens)
-      raise Error, "Failed to trigger screenshot capture." unless res.code.between?(200, 299)
-      
-      # Wait for the screenshot to be generated
-      sleep 2
-      
-      # Second request to get the actual screenshot image
-      path = "capconsole/scapture0.png?#{timestamp_ms}"
-      res = client.get(path: path, headers: tokens)
-      raise Error, "Failed to retrieve screenshot image." unless res.code.between?(200, 299)
-      
-      # Save the screenshot to a file
-      filename = "idrac_screenshot_#{timestamp_ms}.png"
-      File.open(filename, "wb") { |f| f.write(res.body) }
-      
-      # Return the filename
-      filename
-    end
-  end
-end