right_cloud_api_base 0.1.0

data/lib/base/routines/connection_proxies/right_http_connection_proxy.rb

@@ -0,0 +1,224 @@
+#--
+# Copyright (c) 2013 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module RightScale
+  module CloudApi
+    class ConnectionProxy
+      
+      class RightHttpConnectionProxy
+        @@storage = {}
+
+        def self.storage
+          @@storage
+        end
+
+        # Remove dead threads/fibers from the storage
+        def self.clean_storage
+          Utils::remove_dead_fibers_and_threads_from_storage(storage)
+        end
+
+        class Error < CloudApi::Error
+        end
+
+        # Performs an HTTP request.
+        #
+        # @param [Hash] data The API request +data+ storage.
+        #   See {RightScale::CloudApi::ApiManager.initialize_api_request_options} code for its explanation.
+        #
+        def request(data)
+          require "right_http_connection"
+
+          @data = data
+          @data[:response] = {}
+          # Create a connection
+          @uri = @data[:connection][:uri].dup
+
+          # Create/Get RightHttpConnection instance
+          remote_endpoint       = current_endpoint
+          right_http_connection = current_connection
+
+          # Register a callback to close current connection
+          @data[:callbacks][:close_current_connection] = Proc::new{|reason| close_connection(remote_endpoint, reason); log "Current connection closed: #{reason}" }
+
+          # Create a real HTTP request
+          fake = @data[:request][:instance]
+          http_request = "Net::HTTP::#{fake.verb._camelize}"._constantize::new(fake.path)
+          if fake.is_io?
+            http_request.body_stream = fake.body
+          else
+            http_request.body = fake.body
+          end
+          fake.headers.each{|header, value| http_request[header] = value }
+          fake.raw = http_request
+
+          # Set all the options are suported by RightHttpConnection (if they are)
+          http_connection_data = {
+            :server    => @uri.host,
+            :port      => @uri.port,
+            :protocol  => @uri.scheme,
+            :request   => http_request,
+            :exception => ConnectionError
+          }
+
+          # Set all required options
+          http_connection_data[:logger]                       = @data[:options][:cloud_api_logger].logger
+          http_connection_data[:user_agent]                   = @data[:options][:connection_user_agent]   if @data[:options].has_key?(:connection_user_agent)
+          http_connection_data[:ca_file]                      = @data[:options][:connection_ca_file]      if @data[:options].has_key?(:connection_ca_file)
+          http_connection_data[:http_connection_retry_count]  = @data[:options][:connection_retry_count]  if @data[:options].has_key?(:connection_retry_count)
+          http_connection_data[:http_connection_read_timeout] = @data[:options][:connection_read_timeout] if @data[:options].has_key?(:connection_read_timeout)
+          http_connection_data[:http_connection_open_timeout] = @data[:options][:connection_open_timeout] if @data[:options].has_key?(:connection_open_timeout)
+          http_connection_data[:http_connection_retry_delay]  = @data[:options][:connection_retry_delay]  if @data[:options].has_key?(:connection_retry_delay)
+          http_connection_data[:raise_on_timeout]             = @data[:options][:abort_on_timeout]        if @data[:options][:abort_on_timeout]
+          http_connection_data[:cert]                         = @data[:credentials][:cert]                if @data[:credentials].has_key?(:cert)
+          http_connection_data[:key]                          = @data[:credentials][:key]                 if @data[:credentials].has_key?(:key)
+            
+          #log "HttpConnection request: #{http_connection_data.inspect}"
+
+          # Make a request:
+          block = @data[:vars][:system][:block]
+          if block
+            # If block is given - pass there all the chunks of a response and stop
+            # (dont do any parsing, analysing etc)
+            # 
+            # TRB 9/17/07 Careful - because we are passing in blocks, we get a situation where
+            # an exception may get thrown in the block body (which is high-level
+            # code either here or in the application) but gets caught in the
+            # low-level code of HttpConnection.  The solution is not to let any
+            # exception escape the block that we pass to HttpConnection::request.
+            # Exceptions can originate from code directly in the block, or from user
+            # code called in the other block which is passed to response.read_body.
+            # 
+            # TODO: the suggested fix for RightHttpConnection if to catch 
+            # Interrupt and SystemCallError instead of Exception in line 402
+            response = nil
+            begin
+              block_exception = nil
+              # Response.body will be a Net::ReadAdapter instance here - it cant be read as a string.
+              # WEB: On its own, Net::HTTP causes response.body to be a Net::ReadAdapter when you make a request with a block 
+              # that calls read_body on the response.
+              response = right_http_connection.request(http_connection_data) do |res|
+                begin
+                  # Update temp response
+                  @data[:response][:instance] = HTTPResponse::new( res.code,
+                                                                   nil,
+                                                                   res.to_hash,
+                                                                   res )
+                  res.read_body(&block) if res.is_a?(Net::HTTPSuccess)
+                rescue Exception => e
+                  block_exception = e
+                  break
+                end
+              end
+              raise block_exception if block_exception
+            rescue Exception => e
+              right_http_connection.finish(e.message)
+              raise e
+            end
+          else
+            # Things are simple if there is no any block
+            response = right_http_connection.request(http_connection_data)
+          end
+
+          @data[:response][:instance] = HTTPResponse::new( response.code,
+                                                           response.body,
+                                                           response.to_hash,
+                                                           response )
+
+  #        # HACK: KD 
+  #        # 
+  #        # When one uploads a file with pos > 0 and 'content-length' != File.size - pos
+  #        # then the next request through this connection fails with 400 or 505...
+  #        # It seems that it expects the file to be read until EOF.
+  #        # 
+  #        # KIlling the current connection seems to help but it is not good...
+  #        #
+  #        if @data[:request][:instance].body_stream #&& !@data[:request][:instance].body_stream.eof
+  #          pp @data[:request][:instance].body_stream.pos
+  #          log "closing current connection because of an issue when an IO object is not read until EOF"
+  #          @connection.finish
+  #        end
+        end
+        
+        def log(message)     
+          @data[:options][:cloud_api_logger].log(message, :connection_proxy)
+        end
+        
+        #----------------------------
+        # HTTP Connections handling
+        #----------------------------
+
+        def storage # :nodoc:
+          @@storage[Utils::current_thread_and_fiber] ||= {}
+        end
+
+        def current_endpoint # :nodoc:
+          "#{@uri.scheme}://#{@uri.host}:#{@uri.port}"
+        end
+
+        def close_connection(endpoint, reason='') # :nodoc:
+          return nil unless storage[endpoint]
+
+          log "Destroying RightHttpConnection to #{endpoint}, reason: #{reason}"
+          storage[endpoint][:connection].finish(reason)
+        rescue => e
+          log "Exception in close_connection: #{e.class.name}: #{e.message}"
+        ensure
+          storage.delete(endpoint) if endpoint
+        end
+
+        INACTIVE_LIFETIME_LIMIT = 900 # seconds
+
+        # Delete out-of-dated connections for current Thread/Fiber
+        def clean_outdated_connections
+          life_time_scratch = Time::now - INACTIVE_LIFETIME_LIMIT
+          storage.each do |endpoint, connection|
+            if connection[:last_used_at] < life_time_scratch
+              close_connection(endpoint, 'out-of-date')
+            end
+          end
+        end
+
+        # Expire the connection if it has expired.
+        def current_connection # :nodoc:
+          # Remove dead threads/fibers from the storage
+          self.class::clean_storage
+          # Delete out-of-dated connections
+          clean_outdated_connections
+          # Get current_connection
+          endpoint = current_endpoint
+          unless storage[endpoint]
+            storage[endpoint] = {}
+            storage[endpoint][:connection] = Rightscale::HttpConnection.new( :exception => CloudError, 
+                                                                             :logger    => @data[:options][:cloud_api_logger].logger )
+            log "Creating RightHttpConection to #{endpoint.inspect}"
+          else
+            log "Reusing RightHttpConection to #{endpoint.inspect}"
+          end
+          storage[endpoint][:last_used_at] = Time::now
+          storage[endpoint][:connection]
+        end
+      end
+ 
+    end
+  end
+end

data/lib/base/routines/connection_proxy.rb

@@ -0,0 +1,66 @@
+#--
+# Copyright (c) 2013 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module RightScale
+  module CloudApi
+
+    # This routine generifies all HTTP requests so that the main code does not need to worry about
+    # the underlaying libraries (right_http_connection or persistent_connection).
+    #
+    class ConnectionProxy < Routine
+      class Error < CloudApi::Error
+      end
+
+      # Main entry point.
+      #
+      # Performs an HTTP request.
+      #
+      def process
+        unless @connection_proxy
+          # Try to use a user defined connection proxy. The options are:
+          #  - RightScale::CloudApi::ConnectionProxy::RightHttpConnectionProxy,
+          #  - RightScale::CloudApi::ConnectionProxy::NetHttpPersistentProxy
+          connection_proxy_class = data[:options][:connection_proxy]
+          unless connection_proxy_class
+            # If it is not defined then load right_http_connection gem and use it.
+            # connection_proxy_class = ConnectionProxy::RightHttpConnectionProxy
+            connection_proxy_class = RightScale::CloudApi::ConnectionProxy::NetHttpPersistentProxy
+          end
+          @connection_proxy = connection_proxy_class.new
+        end        
+        
+        # Register a call back to close current connection
+        data[:callbacks][:close_current_connection] = Proc::new do |reason|
+          @connection_proxy.close_connection(nil, reason)
+          cloud_api_logger.log("Current connection closed: #{reason}", :connection_proxy)
+        end
+
+        # Make a request.
+        with_timer('HTTP request', :connection_proxy) do
+          @connection_proxy.request(data)
+        end
+      end
+      
+    end
+  end
+end

data/lib/base/routines/request_analyzer.rb

@@ -0,0 +1,122 @@
+#--
+# Copyright (c) 2013 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module RightScale
+  module CloudApi
+
+    # The routine provides *error_pattern* method that is used to define request and response patterns.
+    #
+    # The patterns allows one to control the request processing flow: you can enable retries for
+    # certain API calls or can re-open a connection on HTTP failure.
+    #
+    # The supported actions are:
+    #
+    # Request option:
+    # - :abort_on_timeout - If there was a low level timeout then it should not retry a request
+    #   but should fail. Lets say one made a call to launch some instance and the remote cloud
+    #   launched them but timed out to respond back. The default behavior for the gem is to make
+    #   a retry if a timeout received but in this particular case it will launch the instances
+    #   again. So the solution here is to make the system to fail after the first unsuccessfull
+    #   request.
+    #
+    # Response options:
+    # - :retry - Make a retry if the failed response matches to the pattern.
+    # - :abort - Do not make a retry and fail if the response matches to the pattern (opposite to :retry).
+    # - :disconnect_and_abort - Close a connection and fail.
+    # - :reconnect_and_retry - Reestablish a connection and make a retry.
+    #
+    class RequestAnalyzer < Routine
+
+      class Error < CloudApi::Error
+      end
+
+      REQUEST_ACTIONS  = [ :abort_on_timeout ]
+      REQUEST_KEYS     = [ :verb, :verb!, :path, :path!, :request, :request!, :if ]
+
+      RESPONSE_ACTIONS = [ :disconnect_and_abort, :abort, :reconnect_and_retry, :retry ]
+      RESPONSE_KEYS    = [ :verb, :verb!, :path, :path!, :request, :request!, :code, :code!, :response, :response!, :if ]
+
+      ALL_ACTIONS      = REQUEST_ACTIONS + RESPONSE_ACTIONS
+      
+      module ClassMethods
+
+        def self.extended(base)
+          unless base.respond_to?(:options) && base.options.is_a?(Hash)
+            fail Error::new("RequestAnalyzer routine assumes class being extended responds to :options and returns a hash")
+          end
+        end
+
+        # Adds a new error pattern.
+        # Patterns are analyzed in order of their definition. If one pattern hits the rest are not analyzed.
+        # 
+        # @param [Symbol] action The requested action.
+        # @param [Hash]   error_pattern The requested pattern (see {file:lib/base/helper/utils.rb self.pattern_matches?}).
+        # 
+        # @xample:
+        #    error_pattern :abort_on_timeout,     :path     => /Action=(Run|Create)/
+        #    error_pattern :retry,                :response => /InternalError|Internal Server Error|internal service error/i
+        #    error_pattern :disconnect_and_abort, :code     => /5..|403|408/
+        #    error_pattern :disconnect_and_abort, :code     => /4../, :if => Proc.new{ |opts| rand(100) < 10 }
+        #
+        # @raise [RightScale::CloudApi::RequestAnalyzer::Error] If error_pattern  is not a Hash instance.
+        # @raise [RightScale::CloudApi::RequestAnalyzer::Error] If action is not supported.
+        # @raise [RightScale::CloudApi::RequestAnalyzer::Error] If pattern keys are weird.
+        #
+        def error_pattern(action, error_pattern)
+          action = action.to_sym
+          fail Error::new("Patterns are not set for action #{action.inspect}") if !error_pattern.is_a?(Hash) || error_pattern._blank?
+          fail Error::new("Unsupported action #{action.inspect} for error pattern #{error_pattern.inspect}") unless ALL_ACTIONS.include?(action)
+          unsupported_keys = REQUEST_ACTIONS.include?(action) ? error_pattern.keys - REQUEST_KEYS : error_pattern.keys - RESPONSE_KEYS
+          fail Error::new("Unsupported keys #{unsupported_keys.inspect} for #{action.inspect} in error pattern #{error_pattern.inspect}") unless unsupported_keys._blank?
+          (options[:error_patterns] ||= []) << error_pattern.merge(:action => action)
+        end
+      end
+
+      # The main entry point.
+      #
+      def process
+        # Get a list of accessible error patterns
+        error_patterns = data[:options][:error_patterns] || []
+        opts = { :request  => data[:request][:instance],
+                 :response => nil,
+                 :verb     => data[:request][:verb],
+                 :params   => data[:request][:orig_params].dup}
+        # Walk through all the error patterns and find the first that matches.
+        # RequestAnalyser accepts only REQUEST_ACTIONS (actually "abort_on_timeout" only)
+        request_error_patterns = error_patterns.select{|e| REQUEST_ACTIONS.include?(e[:action])}
+        request_error_patterns.each do |pattern|
+          # If we see any pattern that matches our current state
+          if Utils::pattern_matches?(pattern, opts)
+            # then set a flag to disable retries
+            data[:options][:abort_on_timeout] = true
+            cloud_api_logger.log("Request matches to error pattern: #{pattern.inspect}" , :request_analyzer)
+            break
+          end
+        end
+      end
+    end
+
+  end
+end
+
+

data/lib/base/routines/request_generator.rb

@@ -0,0 +1,48 @@
+#--
+# Copyright (c) 2013 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module RightScale
+  module CloudApi
+
+    # The routine generates a new HTTP request.
+    #
+    class RequestGenerator < Routine
+
+      # Generates an HTTP request instance.
+      #
+      # The request instance must be compatible to what ConnectionProxy is being used expects.
+      #
+      def process
+        request = HTTPRequest::new( data[:request][:verb],
+                                    data[:request][:path],
+                                    data[:request][:body],
+                                    data[:request][:headers] )
+        cloud_api_logger.log("Request generated: #{request.to_s}" ,         :request_generator)
+        cloud_api_logger.log("Request headers:   #{request.headers_info}" , :request_generator)
+        cloud_api_logger.log("Request body:      #{request.body_info}\n",   :request_generator_body) unless (request.body.to_s.size == 0)
+        data[:request][:instance] = request
+      end
+    end
+
+  end
+end

data/lib/base/routines/request_initializer.rb

@@ -0,0 +1,52 @@
+#--
+# Copyright (c) 2013 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module RightScale
+  module CloudApi
+
+    # The routine adds a random token to all the GET requests if the corresponding option is enabled.
+    #
+    class RequestInitializer < Routine
+
+      # Initializes things we may need to initialize.
+      #
+      # Sometimes we may need to add a random token for every request so that remote cloud. This may
+      # be needed when the cloud caches responses for similar requests. Lets say you listed instances
+      # then created one and then listed them again. S-me clouds (rackspace) may start to report the
+      # new seconds after it was created because of the caching they do.
+      #
+      # But if we mix something random onto every request then 2 consecutive list instances calls will
+      # look like they are different and the cloud wont return the cached data.
+      #
+      def process
+        # Add a random thing to every get request
+        if data[:request][:verb] == :get && !data[:options][:random_token]._blank?
+          random_token_name = 'rsrcarandomtoken'
+          random_token_name = data[:options][:random_token].to_s if [String, Symbol].include?(data[:options][:random_token].class)
+          data[:request][:params][random_token_name] = Utils::generate_token
+        end
+      end
+    end
+
+  end
+end

data/lib/base/routines/response_analyzer.rb

@@ -0,0 +1,152 @@
+#--
+# Copyright (c) 2013 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module RightScale
+  module CloudApi
+
+    # The routine analyzes HTTP responses and in the case of HTTP error it takes actions defined
+    # through *error_pattern* definitions.
+    #
+    class ResponseAnalyzer < Routine
+
+      class Error < CloudApi::Error
+      end
+
+      # Analyzes an HTTP response.
+      # 
+      # In the case of 4xx, 5xx HTTP errors the method parses the response body to get the
+      # error message. Then it tries to find an error pattern that would match to the response.
+      # If the pattern found it takes the action (:retry, :abort, :disconnect_and_abort or
+      # :reconnect_and_retry) acordingly to the error patern. If the pattern not fount it just
+      # fails with RightScale::CloudApi::CloudError.
+      #
+      # In the case of 2xx code the method does nothing.
+      #
+      # In the case of any other unexpected HTTP code it fails with RightScale::CloudApi::CloudError.
+      #
+      # @example
+      #    error_pattern :abort_on_timeout,     :path     => /Action=(Run|Create)/
+      #    error_pattern :retry,                :response => /InternalError|Internal Server Error|internal service error/i
+      #    error_pattern :disconnect_and_abort, :code     => /5..|403|408/
+      #    error_pattern :reconnect_and_retry,  :code     => /4../, :if => Proc.new{ |opts| rand(100) < 10 }
+      #
+      def process
+        # Extract the current response and log it.
+        response = data[:response][:instance]
+        unless response.nil?
+          cloud_api_logger.log("Response received: #{response.to_s}", :response_analyzer)
+          cloud_api_logger.log("Response headers:  #{response.headers_info}", :response_analyzer)
+          log_method = (response.is_error? || response.is_redirect?) ? :response_analyzer_body_error : :response_analyzer_body
+          cloud_api_logger.log("Response body:     #{response.body_info}", log_method)
+        end
+
+        code = data[:response][:instance].code
+        body = data[:response][:instance].body
+        close_current_connection_proc = data[:callbacks][:close_current_connection]
+
+        # Analyze the response code.
+        case code
+        when /^(5..|4..)/
+          # Try to parse the received error message.
+          error_message = if data[:options][:response_error_parser]
+                            parser = data[:options][:response_error_parser]
+                            with_timer("Error parsing with #{parser}") do
+                              parser::parse(data[:response][:instance], data[:options])
+                            end
+                          else
+                            "#{code}: #{body.to_s}"
+                          end
+          # Get the list of patterns.
+          error_patterns = data[:options][:error_patterns] || []
+          opts = { :request  => data[:request][:instance],
+                   :response => data[:response][:instance],
+                   :verb     => data[:request][:verb],
+                   :params   => data[:request][:orig_params].dup }
+          # Walk through all the patterns and find the first that matches.
+          error_patterns.each do |pattern|
+            if Utils::pattern_matches?(pattern, opts)
+              cloud_api_logger.log("Error code: #{code}, pattern match: #{pattern.inspect}", :response_analyzer, :warn)
+              # Take the required action.
+              case pattern[:action]
+              when :disconnect_and_abort
+                close_current_connection_proc && close_current_connection_proc.call("Error code: #{code}")
+                fail(HttpError::new(code, error_message))
+              when :reconnect_and_retry
+                close_current_connection_proc && close_current_connection_proc.call("Error code: #{code}")
+                @data[:vars][:retry][:http] = { :code => code, :message => error_message }
+                fail(RetryAttempt::new)
+              when :abort
+                fail(HttpError::new(code, error_message))
+              when :retry
+                invoke_callback_method(data[:options][:before_retry_callback],
+                                       :routine => self,
+                                       :pattern => pattern,
+                                       :opts    => opts)
+                @data[:vars][:retry][:http] = { :code => code, :message => error_message }
+                fail(RetryAttempt::new)
+              end
+            end
+          end
+          # The default behavior: this guy hits when there is no any matching pattern
+          fail(HttpError::new(code, error_message))
+        when /^3..$/
+          # In the case of redirect: update a request URI and retry
+          location = Array(data[:response][:instance].headers['location']).first
+          # ----- AMAZON HACK BEGIN ----------------------------------------------------------
+          # Amazon sometimes hide a location host into a response body.
+          if location._blank? && body && body[/<Endpoint>(.*?)<\/Endpoint>/] && $1
+            data[:connection][:uri].host = $1
+            location = data[:connection][:uri].to_s
+          end
+          # ----- AMAZON HACK END ------------------------------------------------------------
+          # Replace URI and retry if the location was successfully set
+          unless location._blank?
+            data[:connection][:uri] = ::URI.parse(location)
+            old_request = data[:request].delete(:instance)
+            data[:request].delete(:path)
+            cloud_api_logger.log("Redirect detected: #{location.inspect}", :response_analyzer)
+            invoke_callback_method(data[:options][:before_redirect_callback],
+                                   :routine     => self,
+                                   :old_request => old_request,
+                                   :location    => location)
+            raise(RetryAttempt::new)
+          else
+            # ----- OPENSTACK BEGIN ----------------------------------------------------------
+            # some OS services like Glance returns a list of supported api versions with status 300
+            # if there is at least one href in the body we need to further analize it  in the OS manager
+            return true if body && body[/href/]
+            # ----- OPENSTACK END ----------------------------------------------------------
+            raise HttpError::new(code, "Cannot parse a redirect location")
+          end
+        when /^2../
+          # There is nothing to do on 2xx code
+          return true
+        else
+          fail(Error::new("Unexpected response code: #{code.inspect}"))
+        end
+      end
+    end
+
+  end
+end
+