idrac 0.1.29 → 0.1.31

data/lib/idrac/client.rb

@@ -5,6 +5,7 @@ require 'base64'
 require 'uri'
 require 'httparty'
 require 'json'
+require 'colorize'
 
 module IDRAC
   class Client
@@ -37,21 +38,21 @@ module IDRAC
 
     # Force clear all sessions by directly using Basic Auth
     def force_clear_sessions
-      puts "Attempting to force clear all 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"
+        puts "Successfully cleared sessions using Basic Auth".green
         return true
       else
-        puts "Failed to clear sessions using Basic Auth"
+        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..."
+      puts "Attempting to delete all sessions using Basic Authentication...".light_cyan
       
       # First, get the list of sessions
       sessions_url = '/redfish/v1/SessionService/Sessions'
@@ -69,7 +70,7 @@ module IDRAC
         end
         
         if response.status != 200
-          puts "Failed to get sessions list: #{response.status} - #{response.body}"
+          puts "Failed to get sessions list: #{response.status} - #{response.body}".red
           return false
         end
         
@@ -78,7 +79,7 @@ module IDRAC
           sessions_data = JSON.parse(response.body)
           
           if sessions_data['Members'] && sessions_data['Members'].any?
-            puts "Found #{sessions_data['Members'].count} active sessions"
+            puts "Found #{sessions_data['Members'].count} active sessions".light_yellow
             
             # Delete each session
             success = true
@@ -94,9 +95,9 @@ module IDRAC
               end
               
               if delete_response.status == 200 || delete_response.status == 204
-                puts "Successfully deleted session: #{session_url}"
+                puts "Successfully deleted session: #{session_url}".green
               else
-                puts "Failed to delete session #{session_url}: #{delete_response.status}"
+                puts "Failed to delete session #{session_url}: #{delete_response.status}".red
                 success = false
               end
               
@@ -106,15 +107,15 @@ module IDRAC
             
             return success
           else
-            puts "No active sessions found"
+            puts "No active sessions found".light_yellow
             return true
           end
         rescue JSON::ParserError => e
-          puts "Error parsing sessions response: #{e.message}"
+          puts "Error parsing sessions response: #{e.message}".red.bold
           return false
         end
       rescue => e
-        puts "Error during session deletion with Basic Auth: #{e.message}"
+        puts "Error during session deletion with Basic Auth: #{e.message}".red.bold
         return false
       end
     end
@@ -123,7 +124,7 @@ module IDRAC
     def create_redfish_session
       # Skip if we're in direct mode
       if @direct_mode
-        puts "Skipping Redfish session creation (direct mode)"
+        puts "Skipping Redfish session creation (direct mode)".light_yellow
         return false
       end
       
@@ -144,12 +145,12 @@ module IDRAC
           # Extract session location from response headers
           @session_location = response.headers['Location']
           
-          puts "Redfish session created successfully"
+          puts "Redfish session created successfully".green
           @sessions_maxed = false
           return true
         end
       rescue => e
-        puts "First session creation attempt failed: #{e.message}"
+        puts "First session creation attempt failed: #{e.message}".light_red
       end
       
       # If that fails, try with Basic Auth
@@ -172,18 +173,18 @@ module IDRAC
           # Extract session location from response headers
           @session_location = response.headers['Location']
           
-          puts "Redfish session created successfully with Basic Auth"
+          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"
+          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"
+            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"
+              puts "Successfully cleared sessions, trying to create a new session".green
               
               # Try one more time after clearing
               response = connection.post(url) do |req|
@@ -194,31 +195,31 @@ module IDRAC
               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"
+                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}"
+                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"
+              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"
+            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}"
+          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"
+            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}")}"
@@ -228,11 +229,11 @@ module IDRAC
             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"
+              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}"
+              puts "Failed with form-urlencoded too: #{response.status} - #{response.body}".red
               @direct_mode = true
               return false
             end
@@ -242,7 +243,7 @@ module IDRAC
           end
         end
       rescue => e
-        puts "Error during Redfish session creation: #{e.message}"
+        puts "Error during Redfish session creation: #{e.message}".red.bold
         @direct_mode = true
         return false
       end
@@ -253,116 +254,160 @@ module IDRAC
       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['X-Auth-Token'] = @x_auth_token
+          req.headers.merge!(headers)
         end
         
         if response.status == 200 || response.status == 204
-          puts "Redfish session deleted successfully"
+          puts "Redfish session deleted successfully".green
+          @x_auth_token = nil
+          @session_location = nil
+          return true
         else
-          puts "Warning: Failed to delete Redfish session: #{response.status}"
+          puts "Failed to delete Redfish session: #{response.status} - #{response.body}".red
+          return false
         end
       rescue => e
-        puts "Warning: Error during Redfish session deletion: #{e.message}"
-      ensure
-        @x_auth_token = nil
-        @session_location = nil
+        puts "Error during Redfish session deletion: #{e.message}".red.bold
+        return false
       end
     end
 
-    # WebUI login method for screenshot functionality only
+    # Login to the WebUI (for screenshot functionality)
     def webui_login(retry_count = 0)
       # Limit retries to prevent infinite loops
       if retry_count >= 3
-        raise Error, "Failed to login to WebUI after multiple attempts"
+        puts "Maximum retry count reached for WebUI login".red
+        return false
       end
       
-      response = connection.post('/data/login') do |req|
-        req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
-        req.body = "user=#{username}&password=#{password}"
-      end
-
-      if response.status == 200
-        # Extract session ID from response
-        doc = Nokogiri::HTML(response.body)
-        @session_id = doc.at_css('script:contains("_this.SID")').text.match(/_this\.SID\s*=\s*"([^"]+)"/)[1] rescue nil
+      # 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"
         
-        # Store cookies for screenshot functionality
-        @cookies = response.headers['set-cookie']
+        # Create the login payload
+        payload = {
+          'user' => username,
+          'password' => password
+        }
         
-        # Extract forward URL for screenshot functionality
-        xml_doc = Nokogiri::XML(response.body)
-        error_message = xml_doc.at_xpath('//errorMsg')&.text
+        # Make the login request
+        response = HTTParty.post(
+          login_url,
+          body: payload,
+          verify: verify_ssl,
+          headers: { 'Content-Type' => 'application/x-www-form-urlencoded' }
+        )
         
-        if error_message && !error_message.empty?
-          # Check for maximum sessions error
-          if error_message.include?("maximum number of user sessions")
-            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
+        # 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
-              raise Error, "Maximum sessions reached and auto-delete sessions is disabled"
+              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
-          
-          raise Error, "Error Message: #{error_message}"
+        else
+          puts "WebUI login failed: #{response.code} - #{response.body}".red
+          return false
         end
-        
-        forward_url = xml_doc.xpath('//forwardUrl').text
-        return forward_url
-      else
-        raise Error, "WebUI login failed with status #{response.status}: #{response.body}"
+      rescue => e
+        puts "Error during WebUI login: #{e.message}".red.bold
+        return false
       end
     end
 
-    # WebUI logout method for screenshot functionality
+    # Logout from the WebUI
     def webui_logout
       return unless @session_id
       
       begin
-        response = connection.get('/data/logout') do |req|
-          req.headers['Cookie'] = "sessionid=#{@session_id}"
+        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
-        # Ignore errors during logout
-        puts "Warning: Error during WebUI logout: #{e.message}"
-      ensure
-        @session_id = nil
-        @cookies = nil
+        puts "Error during WebUI logout: #{e.message}".red.bold
+        return false
       end
-      
-      true
     end
 
-    # Main login method
+    # Login to iDRAC
     def login
       # If we're in direct mode, skip login attempts
       if @direct_mode
-        puts "Operating in direct mode (no session)"
+        puts "Using direct mode (Basic Auth) for all requests".light_yellow
         return true
       end
       
       # Try to create a Redfish session
       if create_redfish_session
+        puts "Successfully logged in to iDRAC using Redfish session".green
         return true
       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
+        if @sessions_maxed
+          puts "Maximum sessions reached and could not clear sessions".light_red
         else
-          # If we're here, something went wrong with session creation
-          raise Error, "Failed to create a session and direct mode is not enabled"
+          puts "Failed to create Redfish session, falling back to direct mode".light_yellow
         end
+        
+        @direct_mode = true
+        return true
       end
     end
 
-    # Main logout method
+    # Logout from iDRAC
     def logout
       if @x_auth_token
         delete_redfish_session
@@ -372,77 +417,94 @@ module IDRAC
         webui_logout
       end
       
-      true
+      puts "Logged out from iDRAC".green
+      return true
     end
 
+    # Make an authenticated request to the iDRAC
     def authenticated_request(method, path, options = {}, 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
-        puts "Switching to direct mode after multiple authentication failures"
+        puts "Maximum retry count reached for authenticated request".red.bold
+        raise Error, "Maximum retry count reached for authenticated request"
       end
       
-      # Ensure we have a valid session (unless in direct mode)
-      unless @direct_mode
+      # If we're in direct mode, use Basic Auth
+      if @direct_mode
+        # Create Basic Auth header
+        auth_header = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
+        
+        # Add the Authorization header to the request
+        options[:headers] ||= {}
+        options[:headers]['Authorization'] = auth_header
+        
+        # Make the request
         begin
-          login unless @x_auth_token
-        rescue Error => e
-          # 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
-            # Re-raise other errors
-            raise
+          response = connection.send(method, path) do |req|
+            req.headers.merge!(options[:headers])
+            req.body = options[:body] if options[:body]
           end
+          
+          return response
+        rescue => e
+          puts "Error during authenticated request (direct mode): #{e.message}".red.bold
+          raise Error, "Error during authenticated request: #{e.message}"
         end
-      end
-      
-      options[:headers] ||= {}
-      
-      # Use X-Auth-Token if available (preferred Redfish method)
-      if @x_auth_token
-        options[:headers]['X-Auth-Token'] = @x_auth_token
-      elsif @direct_mode
-        # In direct mode, use Basic Auth
-        options[:headers]['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
-      end
-      
-      response = connection.send(method, path, options[:params]) do |req|
-        req.headers.merge!(options[:headers])
-        req.body = options[:body] if options[:body]
-      end
-      
-      # Handle authentication errors
-      if response.status == 401 && !@direct_mode
-        puts "Session expired, re-authenticating..."
-        logout
-        sleep(2)
-        login
-        
-        # Update headers with new authentication
-        options[:headers] ||= {}
+      else
+        # Use X-Auth-Token if available
         if @x_auth_token
+          # Add the X-Auth-Token header to the request
+          options[:headers] ||= {}
           options[:headers]['X-Auth-Token'] = @x_auth_token
-        elsif @direct_mode
-          options[:headers]['Authorization'] = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
-        end
-        
-        response = connection.send(method, path, options[:params]) do |req|
-          req.headers.merge!(options[:headers])
-          req.body = options[:body] if options[:body]
-        end
-        
-        # If we still get a 401, switch to direct mode
-        if response.status == 401 && retry_count < 2
-          @direct_mode = true
-          puts "Switching to direct mode after authentication failure"
-          return authenticated_request(method, path, options, retry_count + 1)
+          
+          # Make the request
+          begin
+            response = connection.send(method, path) do |req|
+              req.headers.merge!(options[:headers])
+              req.body = options[:body] if options[:body]
+            end
+            
+            # Check if the session is still valid
+            if response.status == 401 || response.status == 403
+              puts "Session expired or invalid, attempting to create a new session...".light_yellow
+              
+              # Try to create a new session
+              if create_redfish_session
+                puts "Successfully created a new session, retrying request...".green
+                return authenticated_request(method, path, options, retry_count + 1)
+              else
+                puts "Failed to create a new session, falling back to direct mode...".light_yellow
+                @direct_mode = true
+                return authenticated_request(method, path, options, retry_count + 1)
+              end
+            end
+            
+            return response
+          rescue => e
+            puts "Error during authenticated request (token mode): #{e.message}".red.bold
+            
+            # Try to create a new session
+            if create_redfish_session
+              puts "Successfully created a new session after error, retrying request...".green
+              return authenticated_request(method, path, options, retry_count + 1)
+            else
+              puts "Failed to create a new session after error, falling back to direct mode...".light_yellow
+              @direct_mode = true
+              return authenticated_request(method, path, options, retry_count + 1)
+            end
+          end
+        else
+          # If we don't have a token, try to create a session
+          if create_redfish_session
+            puts "Successfully created a new session, making request...".green
+            return authenticated_request(method, path, options, retry_count + 1)
+          else
+            puts "Failed to create a session, falling back to direct mode...".light_yellow
+            @direct_mode = true
+            return authenticated_request(method, path, options, retry_count + 1)
+          end
         end
       end
-      
-      response
     end
 
     def get(path:, headers: {})