### Home Classes Methods

### In Files

- lib/right_http_connection.rb

### Parent

Object

### Methods

- ::blank?
- ::new
- ::params
- ::params=
- #close
- #finish
- #get_param
- #local_read_size=
- #local_read_size?
- #request
- #socket_read_size=
- #socket_read_size?

### Files

- README.txt

### Class/Module Index

Quicksearch

- Rightscale
- Rightscale::HttpConnection

No matching classes.

# Rightscale::HttpConnection

HttpConnection maintains a persistent HTTP connection to a remote server. Each instance maintains its own unique connection to the HTTP server. HttpConnection makes a best effort to receive a proper HTTP response from the server, although it does not guarantee that this response contains a HTTP Success code.

On low-level errors (TCP/IP errors) HttpConnection invokes a reconnect and retry algorithm. Note that although each HttpConnection object has its own connection to the HTTP server, error handling is shared across all connections to a server. For example, if there are three connections to www.somehttpserver.com, a timeout error on one of those connections will cause all three connections to break and reconnect. A connection will not break and reconnect, however, unless a request becomes active on it within a certain amount of time after the error (as specified by HTTP_CONNECTION_RETRY_DELAY). An idle connection will not break even if other connections to the same server experience errors.

A HttpConnection will retry a request a certain number of times (as defined by HTTP_CONNNECTION_RETRY_COUNT). If all the retries fail, an exception is thrown and all HttpConnections associated with a server enter a probationary period defined by HTTP_CONNECTION_RETRY_DELAY. If the user makes a new request subsequent to entering probation, the request will fail immediately with the same exception thrown on probation entry. This is so that if the HTTP server has gone down, not every subsequent request must wait for a connect timeout before failing. After the probation period expires, the internal state of the HttpConnection is reset and subsequent requests have the full number of potential reconnects and retries available to them.

### Constants

HTTP_CONNECTION_OPEN_TIMEOUT

  Throw a Timeout::Error if a connection isn't established within this number of seconds

HTTP_CONNECTION_READ_TIMEOUT

  Throw a Timeout::Error if no data have been read on this connnection within this number of seconds

HTTP_CONNECTION_RETRY_COUNT

  Number of times to retry the request after encountering the first error

HTTP_CONNECTION_RETRY_DELAY

  Length of the post-error probationary period during which all requests will fail

### Attributes

http[RW]
logger[RW]
params[RW]
server[RW]

### Public Class Methods

blank?(obj) click to toggle source

    # File lib/right_http_connection.rb, line 419
    def self.blank?(obj)
      case obj
      when NilClass, FalseClass
        true
      when TrueClass, Numeric
        false
      when Array, Hash
        obj.empty?
      when String
        obj.empty? || obj.strip.empty?
      else
        # "", "   ", nil, [], and {} are blank
        if obj.respond_to?(:empty?) && obj.respond_to?(:strip)
          obj.empty? or obj.strip.empty?
        elsif obj.respond_to?(:empty?)
          obj.empty?
        else
          !obj
        end
      end
    end

new(params={}) click to toggle source

Params hash:

    :user_agent => 'www.HostName.com'    # String to report as HTTP User agent
    :ca_file    => 'path_to_file'        # A path of a CA certification file in PEM format. The file can contain several CA certificates.
    :logger     => Logger object         # If omitted, HttpConnection logs to STDOUT
    :exception  => Exception to raise    # The type of exception to raise if a request repeatedly fails. RuntimeError is raised if this parameter is omitted.
    :http_connection_retry_count         # by default == Rightscale::HttpConnection.params[:http_connection_retry_count]
    :http_connection_open_timeout        # by default == Rightscale::HttpConnection.params[:http_connection_open_timeout]
    :http_connection_read_timeout        # by default == Rightscale::HttpConnection.params[:http_connection_read_timeout]
    :http_connection_retry_delay         # by default == Rightscale::HttpConnection.params[:http_connection_retry_delay]

    # File lib/right_http_connection.rb, line 128
    def initialize(params={})
      @params                                = params
      @params[:http_connection_retry_count]  ||= @@params[:http_connection_retry_count]
      @params[:http_connection_open_timeout] ||= @@params[:http_connection_open_timeout]
      @params[:http_connection_read_timeout] ||= @@params[:http_connection_read_timeout]
      @params[:http_connection_retry_delay]  ||= @@params[:http_connection_retry_delay]
      @http                                  = nil
      @server                                = nil
      @logger                                = get_param(:logger) ||
          (RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)) ||
          Logger.new(STDOUT)
    end

params() click to toggle source

Query the global (class-level) parameters:

    :user_agent => 'www.HostName.com'    # String to report as HTTP User agent
    :ca_file    => 'path_to_file'        # Path to a CA certification file in PEM format. The file can contain several CA certificates.  If this parameter isn't set, HTTPS certs won't be verified.
    :logger     => Logger object         # If omitted, HttpConnection logs to STDOUT
    :exception  => Exception to raise    # The type of exception to raise
                                         # if a request repeatedly fails. RuntimeError is raised if this parameter is omitted.
    :http_connection_retry_count         # by default == Rightscale::HttpConnection::HTTP_CONNECTION_RETRY_COUNT
    :http_connection_open_timeout        # by default == Rightscale::HttpConnection::HTTP_CONNECTION_OPEN_TIMEOUT
    :http_connection_read_timeout        # by default == Rightscale::HttpConnection::HTTP_CONNECTION_READ_TIMEOUT
    :http_connection_retry_delay         # by default == Rightscale::HttpConnection::HTTP_CONNECTION_RETRY_DELAY

    # File lib/right_http_connection.rb, line 101
    def self.params
      @@params
    end

params=(params) click to toggle source

Set the global (class-level) parameters

    # File lib/right_http_connection.rb, line 106
    def self.params=(params)
      @@params = params
    end

### Public Instance Methods

close(reason='') click to toggle source

    # File lib/right_http_connection.rb, line 415
    def close(reason='')
      finish
    end

finish(reason = '') click to toggle source

    # File lib/right_http_connection.rb, line 407
    def finish(reason = '')
      if @http && @http.started?
        reason = ", reason: '#{reason}'" unless self.class.blank?(reason)
        @logger.debug("Closing #{@http.use_ssl? ? 'HTTPS' : 'HTTP'} connection to #{@http.address}:#{@http.port}#{reason}")
        @http.finish
      end
    end

get_param(name) click to toggle source

    # File lib/right_http_connection.rb, line 141
    def get_param(name)
      @params[name] || @@params[name]
    end

local_read_size=(newsize) click to toggle source

Set the maximum size (in bytes) of a single read from local data sources like files. This can be used to tune the performance of, for example, a streaming PUT of a large buffer.

    # File lib/right_http_connection.rb, line 169
    def local_read_size=(newsize)
      Net::HTTPGenericRequest.local_read_size=(newsize)
    end

local_read_size?() click to toggle source

Query for the maximum size (in bytes) of a single read from local data sources like files. This is important, for example, in a streaming PUT of a large buffer.

    # File lib/right_http_connection.rb, line 162
    def local_read_size?
      Net::HTTPGenericRequest.local_read_size?
    end

request(request_params, &block) click to toggle source

Send HTTP request to server

    request_params hash:
    :server   => 'www.HostName.com'   # Hostname or IP address of HTTP server
    :port     => '80'                 # Port of HTTP server
    :protocol => 'https'              # http and https are supported on any port
    :request  => 'requeststring'      # Fully-formed HTTP request to make

Raises RuntimeError, Interrupt, and params (if specified in new).

    # File lib/right_http_connection.rb, line 319
    def request(request_params, &block)
      # We save the offset here so that if we need to retry, we can return the file pointer to its initial position
      mypos = get_fileptr_offset(request_params)
      loop do
        # if we are inside a delay between retries: no requests this time!
        if error_count > @params[:http_connection_retry_count] &&
            error_time + @params[:http_connection_retry_delay] > Time.now
          # store the message (otherwise it will be lost after error_reset and
          # we will raise an exception with an empty text)
          banana_message_text = banana_message
          @logger.warn("#{err_header} re-raising same error: #{banana_message_text} " +
                           "-- error count: #{error_count}, error age: #{Time.now.to_i - error_time.to_i}")
          exception = get_param(:exception) || RuntimeError
          raise exception.new(banana_message_text)
        end

        # try to connect server(if connection does not exist) and get response data
        begin
          request_params[:protocol] ||= (request_params[:port] == 443 ? 'https' : 'http')

          request                   = request_params[:request]
          request['User-Agent']     = get_param(:user_agent) || ''

          # (re)open connection to server if none exists or params has changed
          unless @http &&
              @http.started? &&
              @server == request_params[:server] &&
              @port == request_params[:port] &&
              @protocol == request_params[:protocol]
            start(request_params)
          end

          # Detect if the body is a streamable object like a file or socket.  If so, stream that
          # bad boy.
          setup_streaming(request)
          response = @http.request(request, &block)

          error_reset
          eof_reset
          return response

          # We treat EOF errors and the timeout/network errors differently.  Both
          # are tracked in different statistics blocks.  Note below that EOF
          # errors will sleep for a certain (exponentially increasing) period.
          # Other errors don't sleep because there is already an inherent delay
          # in them; connect and read timeouts (for example) have already
          # 'slept'.  It is still not clear which way we should treat errors
          # like RST and resolution failures.  For now, there is no additional
          # delay for these errors although this may change in the future.

          # EOFError means the server closed the connection on us.
        rescue EOFError => e
          @logger.debug("#{err_header} server #{@server} closed connection")
          @http = nil

          # if we have waited long enough - raise an exception...
          if raise_on_eof_exception?
            exception = get_param(:exception) || RuntimeError
            @logger.warn("#{err_header} raising #{exception} due to permanent EOF being received from #{@server}, error age: #{Time.now.to_i - eof_time.to_i}")
            raise exception.new("Permanent EOF is being received from #{@server}.")
          else
            # ... else just sleep a bit before new retry
            sleep(add_eof)
            # We will be retrying the request, so reset the file pointer
            reset_fileptr_offset(request, mypos)
          end
        rescue Exception => e # See comment at bottom for the list of errors seen...
          @http = nil
          # if ctrl+c is pressed - we have to reraise exception to terminate proggy
          if e.is_a?(Interrupt) && !(e.is_a?(Errno::ETIMEDOUT) || e.is_a?(Timeout::Error))
            @logger.debug("#{err_header} request to server #{@server} interrupted by ctrl-c")
            raise
          elsif e.is_a?(ArgumentError) && e.message.include?('wrong number of arguments (5 for 4)')
            # seems our net_fix patch was overriden...
            exception = get_param(:exception) || RuntimeError
            raise exception.new('incompatible Net::HTTP monkey-patch')
          end
          # oops - we got a banana: log it
          error_add(e.message)
          @logger.warn("#{err_header} request failure count: #{error_count}, exception: #{e.inspect}")

          # We will be retrying the request, so reset the file pointer
          reset_fileptr_offset(request, mypos)

        end
      end
    end

socket_read_size=(newsize) click to toggle source

Set the maximum size (in bytes) of a single read from the underlying socket. For bulk transfer, especially over fast links, this is value is critical to performance.

    # File lib/right_http_connection.rb, line 155
    def socket_read_size=(newsize)
      Net::BufferedIO.socket_read_size=(newsize)
    end

socket_read_size?() click to toggle source

Query for the maximum size (in bytes) of a single read from the underlying socket. For bulk transfer, especially over fast links, this is value is critical to performance.

    # File lib/right_http_connection.rb, line 148
    def socket_read_size?
      Net::BufferedIO.socket_read_size?
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.