idrac 0.1.92 → 0.3.2

data/lib/idrac/boot.rb

@@ -0,0 +1,357 @@
+require 'json'
+require 'colorize'
+
+module IDRAC
+  module BootManagementMethods
+    # Get BIOS boot options
+    def get_bios_boot_options
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/BootSources")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          if data["Attributes"]["UefiBootSeq"].blank?
+            puts "Not in UEFI mode".red
+            return false
+          end
+          
+          boot_order = []
+          boot_options = []
+          
+          data["Attributes"]["UefiBootSeq"].each do |seq|
+            puts "#{seq["Name"]} > #{seq["Enabled"]}".yellow
+            boot_options << seq["Name"]
+            boot_order << seq["Name"] if seq["Enabled"]
+          end
+          
+          return {
+            boot_options: boot_options,
+            boot_order: boot_order
+          }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse BIOS boot options response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get BIOS boot options. Status code: #{response.status}"
+      end
+    end
+    
+    # Ensure UEFI boot mode
+    def ensure_uefi_boot
+      response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/Bios")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          if data["Attributes"]["BootMode"] == "Uefi"
+            puts "System is already in UEFI boot mode".green
+            return true
+          else
+            puts "System is not in UEFI boot mode. Setting to UEFI...".yellow
+            
+            # Create payload for UEFI boot mode
+            payload = {
+              "Attributes": {
+                "BootMode": "Uefi"
+              }
+            }
+            
+            # If iDRAC 9, we need to enable HddPlaceholder
+            if get_idrac_version == 9
+              payload[:Attributes][:HddPlaceholder] = "Enabled"
+            end
+            
+            response = authenticated_request(
+              :patch, 
+              "/redfish/v1/Systems/System.Embedded.1/Bios/Settings",
+              body: payload.to_json,
+              headers: { 'Content-Type': 'application/json' }
+            )
+            
+            if response.status.between?(200, 299)
+              puts "UEFI boot mode set. A system reboot is required for changes to take effect.".green
+              
+              # Check for job creation
+              if response.headers["Location"]
+                job_id = response.headers["Location"].split("/").last
+                wait_for_job(job_id)
+              end
+              
+              return true
+            else
+              error_message = "Failed to set UEFI boot mode. Status code: #{response.status}"
+              
+              begin
+                error_data = JSON.parse(response.body)
+                if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+                  error_info = error_data["error"]["@Message.ExtendedInfo"].first
+                  error_message += ", Message: #{error_info['Message']}"
+                end
+              rescue
+                # Ignore JSON parsing errors
+              end
+              
+              raise Error, error_message
+            end
+          end
+        rescue JSON::ParserError
+          raise Error, "Failed to parse BIOS response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get BIOS information. Status code: #{response.status}"
+      end
+    end
+    
+    # Set boot order (HD first)
+    def set_boot_order_hd_first
+      # First ensure we're in UEFI mode
+      ensure_uefi_boot
+      
+      # Get available boot options
+      boot_options_response = authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1/BootOptions?$expand=*($levels=1)")
+      
+      if boot_options_response.status == 200
+        begin
+          data = JSON.parse(boot_options_response.body)
+          
+          puts "Available boot options:"
+          data["Members"].each { |m| puts "\t#{m['DisplayName']} -> #{m['Id']}" }
+          
+          # Find RAID controller or HD
+          device = data["Members"].find { |m| m["DisplayName"] =~ /RAID Controller/ }
+          # Sometimes it's named differently
+          device ||= data["Members"].find { |m| m["DisplayName"] =~ /ubuntu/i }
+          device ||= data["Members"].find { |m| m["DisplayName"] =~ /UEFI Hard Drive/i }
+          device ||= data["Members"].find { |m| m["DisplayName"] =~ /Hard Drive/i }
+          
+          if device.nil?
+            raise Error, "No bootable hard drive or RAID controller found in boot options"
+          end
+          
+          boot_id = device["Id"]
+          
+          # Set boot order
+          response = authenticated_request(
+            :patch, 
+            "/redfish/v1/Systems/System.Embedded.1",
+            body: { "Boot": { "BootOrder": [boot_id] } }.to_json,
+            headers: { 'Content-Type': 'application/json' }
+          )
+          
+          if response.status.between?(200, 299)
+            puts "Boot order set to HD first".green
+            return true
+          else
+            error_message = "Failed to set boot order. Status code: #{response.status}"
+            
+            begin
+              error_data = JSON.parse(response.body)
+              if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+                error_info = error_data["error"]["@Message.ExtendedInfo"].first
+                error_message += ", Message: #{error_info['Message']}"
+              end
+            rescue
+              # Ignore JSON parsing errors
+            end
+            
+            raise Error, error_message
+          end
+        rescue JSON::ParserError
+          raise Error, "Failed to parse boot options response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get boot options. Status code: #{boot_options_response.status}"
+      end
+    end
+    
+    # Configure BIOS settings
+    def configure_bios_settings(settings)
+      response = authenticated_request(
+        :patch, 
+        "/redfish/v1/Systems/System.Embedded.1/Bios/Settings",
+        body: { "Attributes": settings }.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "BIOS settings configured. A system reboot is required for changes to take effect.".green
+        
+        # Check if we need to wait for a job
+        if response.headers["Location"]
+          job_id = response.headers["Location"].split("/").last
+          wait_for_job(job_id)
+        end
+        
+        return true
+      else
+        error_message = "Failed to configure BIOS settings. Status code: #{response.status}"
+        
+        begin
+          error_data = JSON.parse(response.body)
+          if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+            error_info = error_data["error"]["@Message.ExtendedInfo"].first
+            error_message += ", Message: #{error_info['Message']}"
+          end
+        rescue
+          # Ignore JSON parsing errors
+        end
+        
+        raise Error, error_message
+      end
+    end
+    
+    # Configure BIOS to optimize for OS power management
+    def set_bios_os_power_control
+      settings = {
+        "ProcCStates": "Enabled",      # Processor C-States
+        "SysProfile": "PerfPerWattOptimizedOs",
+        "ProcPwrPerf": "OsDbpm",       # OS Power Management
+        "PcieAspmL1": "Enabled"        # PCIe Active State Power Management
+      }
+      
+      configure_bios_settings(settings)
+    end
+    
+    # Configure BIOS to ignore boot errors
+    def set_bios_ignore_errors(value = true)
+      configure_bios_settings({
+        "ErrPrompt": value ? "Disabled" : "Enabled"
+      })
+    end
+    
+    # Get iDRAC version - needed for boot management differences
+    def get_idrac_version
+      response = authenticated_request(:get, "/redfish/v1")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          redfish = data["RedfishVersion"]
+          server = response.headers["server"]
+          
+          case server.to_s.downcase
+          when /appweb\/4.5.4/, /idrac\/8/
+            return 8
+          when /apache/, /idrac\/9/
+            return 9
+          else
+            # Try to determine by RedfishVersion as fallback
+            if redfish == "1.4.0"
+              return 8
+            elsif redfish == "1.18.0"
+              return 9
+            else
+              raise Error, "Unknown iDRAC version: #{server} / #{redfish}"
+            end
+          end
+        rescue JSON::ParserError
+          raise Error, "Failed to parse iDRAC response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get iDRAC information. Status code: #{response.status}"
+      end
+    end
+    
+    # Create System Configuration Profile for BIOS settings
+    def create_scp_for_bios(settings)
+      attributes = []
+      
+      settings.each do |key, value|
+        attributes << {
+          "Name": key.to_s,
+          "Value": value,
+          "Set On Import": "True"
+        }
+      end
+      
+      scp = {
+        "SystemConfiguration": {
+          "Components": [
+            {
+              "FQDD": "BIOS.Setup.1-1",
+              "Attributes": attributes
+            }
+          ]
+        }
+      }
+      
+      return scp
+    end
+    
+    # Import System Configuration Profile for advanced configurations
+    def import_system_configuration(scp, target: "ALL", reboot: false)
+      params = {
+        "ImportBuffer": JSON.pretty_generate(scp),
+        "ShareParameters": {
+          "Target": target
+        }
+      }
+      
+      # Configure shutdown behavior
+      params["ShutdownType"] = "Forced"
+      params["HostPowerState"] = reboot ? "On" : "Off"
+      
+      response = authenticated_request(
+        :post, 
+        "/redfish/v1/Managers/iDRAC.Embedded.1/Actions/Oem/EID_674_Manager.ImportSystemConfiguration",
+        body: params.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        # Check if we need to wait for a job
+        if response.headers["location"]
+          job_id = response.headers["location"].split("/").last
+          
+          job = wait_for_job(job_id)
+          
+          # Check for task completion status
+          if job["TaskState"] == "Completed" && job["TaskStatus"] == "OK"
+            puts "System configuration imported successfully".green
+            return true
+          else
+            # If there's an error message with a line number, surface it
+            error_message = "Failed to import system configuration"
+            
+            if job["Messages"]
+              job["Messages"].each do |m|
+                puts "#{m["Message"]} (#{m["Severity"]})".red
+                
+                # Check for line number in error message
+                if m["Message"] =~ /line (\d+)/
+                  line_num = $1.to_i
+                  lines = JSON.pretty_generate(scp).split("\n")
+                  puts "Error near line #{line_num}:".red
+                  ((line_num-3)..(line_num+1)).each do |ln|
+                    puts "#{ln}: #{lines[ln-1]}" if ln > 0 && ln <= lines.length
+                  end
+                end
+              end
+            end
+            
+            raise Error, error_message
+          end
+        else
+          puts "System configuration import started, but no job ID was returned".yellow
+          return true
+        end
+      else
+        error_message = "Failed to import system configuration. Status code: #{response.status}"
+        
+        begin
+          error_data = JSON.parse(response.body)
+          if error_data["error"] && error_data["error"]["@Message.ExtendedInfo"]
+            error_info = error_data["error"]["@Message.ExtendedInfo"].first
+            error_message += ", Message: #{error_info['Message']}"
+          end
+        rescue
+          # Ignore JSON parsing errors
+        end
+        
+        raise Error, error_message
+      end
+    end
+  end
+end 

data/lib/idrac/client.rb

@@ -10,15 +10,19 @@ require 'colorize'
 module IDRAC
   class Client
     attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, :auto_delete_sessions, :session, :web
-    attr_accessor :direct_mode, :verbosity
+    attr_accessor :direct_mode, :verbosity, :retry_count, :retry_delay
     
     include PowerMethods
     include SessionMethods
     include Debuggable
     include JobMethods
     include LifecycleMethods
+    include StorageMethods
+    include SystemComponentMethods
+    include VirtualMediaMethods
+    include BootManagementMethods
 
-    def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: false, direct_mode: false, auto_delete_sessions: true)
+    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 = host
       @username = username
       @password = password
@@ -28,6 +32,8 @@ module IDRAC
       @direct_mode = direct_mode
       @auto_delete_sessions = auto_delete_sessions
       @verbosity = 0
+      @retry_count = retry_count
+      @retry_delay = retry_delay
       
       # Initialize the session and web classes
       @session = Session.new(self)
@@ -76,107 +82,165 @@ module IDRAC
       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
-        debug "Maximum retry count reached for authenticated request", 1, :red
-        raise Error, "Maximum retry count reached for authenticated request"
+    # Send an authenticated request to the iDRAC
+    def authenticated_request(method, path, options = {})
+      with_retries do
+        _perform_authenticated_request(method, path, options)
       end
+    end
+
+    def get(path:, headers: {})
+      with_retries do
+        _perform_get(path: path, headers: headers)
+      end
+    end
+
+    private
+    
+    # Implementation of authenticated request without retry logic
+    def _perform_authenticated_request(method, path, options = {}, retry_count = 0)
+      # Check retry count to prevent infinite recursion
+      if retry_count >= @retry_count
+        debug "Maximum retry count reached", 1, :red
+        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
+      body = options[:body]
+      headers = options[:headers] || {}
+      
+      # Add client headers
+      headers['User-Agent'] ||= 'iDRAC Ruby Client'
+      headers['Accept'] ||= 'application/json'
+      
       # If we're in direct mode, use Basic Auth
       if @direct_mode
         # Create Basic Auth header
         auth_header = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
+        headers['Authorization'] = auth_header
+        debug "Using Basic Auth for request (direct mode)", 2
         
-        # Add the Authorization header to the request
-        options[:headers] ||= {}
-        options[:headers]['Authorization'] = auth_header
-        
-        debug "Using Basic Auth for request", 2
-        
-        # Make the request
         begin
-          response = connection.send(method, path) do |req|
-            req.headers.merge!(options[:headers])
-            req.body = options[:body] if options[:body]
-          end
+          # Make the request directly
+          response = session.connection.run_request(
+            method,
+            path.sub(/^\//, ''),
+            body,
+            headers
+          )
+          
+          debug "Response status: #{response.status}", 2
           
-          debug "Response status: #{response.status}", 1
-          debug "Response headers: #{response.headers.inspect}", 2
-          debug "Response body: #{response.body}", 3 if response.body
+          # 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 => e
+          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
-          debug "Error during authenticated request (direct mode): #{e.message}", 1, :red
+          debug "Error during direct mode request: #{e.message}", 1, :red
           raise Error, "Error during authenticated request: #{e.message}"
         end
-      else
-        # Use X-Auth-Token if available
-        if session.x_auth_token
-          # Add the X-Auth-Token header to the request
-          options[:headers] ||= {}
-          options[:headers]['X-Auth-Token'] = session.x_auth_token
+      # 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 request", 2
+          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
           
-          # Make the request
-          begin
-            response = connection.send(method, path) do |req|
-              req.headers.merge!(options[:headers])
-              req.body = options[:body] if options[:body]
-            end
-            
-            debug "Response status: #{response.status}", 1
-            debug "Response headers: #{response.headers.inspect}", 2
-            debug "Response body: #{response.body}", 3 if response.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
             
-            # Check if the session is still valid
-            if response.status == 401 || response.status == 403
-              debug "Session expired or invalid, attempting to create a new session...", 1, :light_yellow
-              
-              # Try to create a new session
-              if session.create
-                debug "Successfully created a new session, retrying request...", 1, :green
-                return authenticated_request(method, path, options, retry_count + 1)
-              else
-                debug "Failed to create a new session, falling back to direct mode...", 1, :light_yellow
-                @direct_mode = true
-                return authenticated_request(method, path, options, retry_count + 1)
-              end
+            # If session.delete returns true, the session was successfully deleted
+            if session.delete
+              debug "Successfully cleared expired session", 1, :green
             end
             
-            return response
-          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 authenticated_request(method, path, options, retry_count + 1)
+              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 error, falling back to direct mode...", 1, :light_yellow
+              debug "Failed to create a new session after expiration, falling back to direct mode...", 1, :light_yellow
               @direct_mode = true
-              return authenticated_request(method, path, options, retry_count + 1)
+              return _perform_authenticated_request(method, path, options, retry_count + 1)
             end
           end
-        else
-          # If we don't have a token, try to create a session
+          
+          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, making request...", 1, :green
-            return authenticated_request(method, path, options, retry_count + 1)
+            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 session, falling back to direct mode...", 1, :light_yellow
+            debug "Failed to create a new session after error, falling back to direct mode...", 1, :light_yellow
             @direct_mode = true
-            return authenticated_request(method, path, options, retry_count + 1)
+            return _perform_authenticated_request(method, path, options, retry_count + 1)
           end
         end
+      else
+        # If we don't have a token, try to create a session
+        if session.create
+          debug "Successfully created a new session, making 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
+          @direct_mode = true
+          return _perform_authenticated_request(method, path, options, retry_count + 1)
+        end
       end
     end
 
-    def get(path:, headers: {})
+    def _perform_get(path:, headers: {})
       # For screenshot functionality, we need to use the WebUI cookies
       if web.cookies.nil? && path.include?('screen/screen.jpg')
         web.login unless web.session_id
@@ -216,6 +280,8 @@ module IDRAC
       response
     end
 
+    public
+
     def screenshot
       web.capture_screenshot
     end
@@ -234,5 +300,34 @@ module IDRAC
         raise Error, "Failed to get Redfish version: #{response.status} - #{response.body}"
       end
     end
+
+    # Execute a block with automatic retries
+    # @param max_retries [Integer] Maximum number of retry attempts
+    # @param initial_delay [Integer] Initial delay in seconds between retries (increases exponentially)
+    # @param error_classes [Array] Array of error classes to catch and retry
+    # @yield The block to execute with retries
+    # @return [Object] The result of the block
+    def with_retries(max_retries = nil, initial_delay = nil, error_classes = nil)
+      # Use instance variables if not specified
+      max_retries ||= @retry_count
+      initial_delay ||= @retry_delay
+      error_classes ||= [StandardError]
+      
+      retries = 0
+      begin
+        yield
+      rescue *error_classes => e
+        retries += 1
+        if retries <= max_retries
+          delay = initial_delay * (retries ** 1.5).to_i  # Exponential backoff
+          debug "RETRY: #{e.message} - Attempt #{retries}/#{max_retries}, waiting #{delay}s", 1, :yellow
+          sleep delay
+          retry
+        else
+          debug "MAX RETRIES REACHED: #{e.message} after #{max_retries} attempts", 1, :red
+          raise e
+        end
+      end
+    end
   end
 end