right_http_connection 1.2.3 → 1.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ba2dac9f5194cfcb8a8e6dec24f973418d07f22
+  data.tar.gz: 59e6d3f82e45ca7679849320fc7fd89f6e776d20
+SHA512:
+  metadata.gz: fd754b030589555f947f2a52bb64c4d3524c902f3e0d95c00fbecf5a340c06d7d6353360763b225b3e05464357610e2dae54d7e21df17b899a65c3bef5430c02
+  data.tar.gz: 2ee74c4fc7cf86908f8a06b96be6cd892aeb25e16a345ea959e0fbe7907712a126c73704c8a3da013dec9443cecd8cc6e1caace3ebd4737c7e0e4da4e5287488

data/History.txt

@@ -49,4 +49,38 @@ Initial public release
 
 - Added support for setting retry & timeout parameters in the constructor
 - Improve handling of data streams during upload: if there is a failure and a retry, reset
-  the seek pointer for the subsequent re-request
+  the seek pointer for the subsequent re-request
+
+== 1.2.4 
+
+*  r4984, konstantin, 2008-08-11 14:49:18 +0400
+  * fixed a bug: <NoMethodError: You have a nil object when you didn't expect it!
+                  The error occurred while evaluating nil.body_stream>
+
+== 1.2.5
+
+- ActiveSupport dependency removal 
+
+
+== 1.3.0
+ - Added:
+   - support for using through proxies
+   - functional tests
+
+== 1.3.1
+ - Added:
+   - SSL certificate handshake support
+   - more specs
+   - ability to give client side key and certificate inline
+ - Fixed: some minor glitches
+
+== 1.4.0
+  - Added
+    - license
+    - HTTP_PROXY env variable support
+  - Fixed
+    - context-length issue (thx kristianm)
+    - exception handling
+    - connection is now closed on any exception
+    - connection is reestablished when credentials change
+    - some other minor bugs

data/Manifest.txt

@@ -4,4 +4,5 @@ README.txt
 Rakefile
 lib/net_fix.rb
 lib/right_http_connection.rb
+lib/support.rb
 setup.rb

data/Rakefile

@@ -1,59 +1,34 @@
 require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
 require 'rake'
 require 'rake/clean'
 require 'rake/testtask'
 require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rake/contrib/rubyforgepublisher'
+#require 'rake/gempackagetask'
+#require 'rake/rdoctask'
+#require 'rake/contrib/rubyforgepublisher'
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
 require 'fileutils'
-require 'hoe'
 include FileUtils
 require File.join(File.dirname(__FILE__), 'lib', 'right_http_connection')
 
-AUTHOR = 'RightScale'  # can also be an array of Authors
-EMAIL = "support@rightscale.com"
-DESCRIPTION = "RightScale's robust HTTP/S connection module"
-GEM_NAME = 'right_http_connection' # what ppl will type to install your gem
-RUBYFORGE_PROJECT = 'rightaws' # The unix name for your project
-HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
-DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
-
-NAME = "right_http_connection"
-REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
-VERS = RightHttpConnection::VERSION::STRING + (REV ? ".#{REV}" : "")
-CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
-RDOC_OPTS = ['--quiet', '--title', 'right_http_connection documentation',
-    "--opname", "index.html",
-    "--line-numbers", 
-    "--main", "README",
-    "--inline-source"]
-
-class Hoe
-  def extra_deps 
-    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
-  end 
-end
+Bundler::GemHelper.install_tasks
+
+=begin
 
-# Generate all the Rake tasks
-# Run 'rake -T' to see list of generated tasks (from gem root directory)
-hoe = Hoe.new(GEM_NAME, VERS) do |p|
-  p.author = AUTHOR 
-  p.description = DESCRIPTION
-  p.email = EMAIL
-  p.summary = DESCRIPTION
-  p.url = HOMEPATH
-  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
-  p.test_globs = ["test/**/test_*.rb"]
-  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
-  p.remote_rdoc_dir = "right_http_gem_doc"
-  
-  # == Optional
-  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
-  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
-  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+# == Gem == #
+
+gemtask = Rake::GemPackageTask.new(Gem::Specification.load("right_http_connection.gemspec")) do |package|
+  package.package_dir = ENV['PACKAGE_DIR'] || 'pkg'
+  package.need_zip = true
+  package.need_tar = true
 end
 
+directory gemtask.package_dir
+
+CLEAN.include(gemtask.package_dir)
 
 desc 'Generate website files'
 task :website_generate do
@@ -88,3 +63,30 @@ task :check_version do
     exit
   end
 end
+=end
+
+task :default => 'spec'
+
+# == Unit Tests == #
+
+desc "Run unit tests"
+RSpec::Core::RakeTask.new
+
+namespace :spec do
+  desc "Run unit tests with RCov"
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.rcov = true
+    t.rcov_opts = %q[--exclude "spec"]
+  end
+
+  desc "Print Specdoc for unit tests"
+  RSpec::Core::RakeTask.new(:doc) do |t|
+    t.rspec_opts = ["--format", "documentation"]
+  end
+end
+
+# == Functional tests == #
+desc "Run functional tests"
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w{--color --format pretty}
+end

data/lib/{net_fix.rb → base/net_fix.rb}

@@ -25,6 +25,7 @@
 # Net::HTTP and Net::HTTPGenericRequest fixes to support 100-continue on 
 # POST and PUT. The request must have 'expect' field set to '100-continue'.
 
+require 'timeout'
 
 module Net
   
@@ -48,7 +49,7 @@ module Net
     end
 
     def rbuf_fill
-      timeout(@read_timeout) {
+      Timeout.timeout(@read_timeout) {
         @rbuf << @io.sysread(@@socket_read_size)
       }
     end
@@ -91,18 +92,30 @@ module Net
     private
 
     def send_request_with_body(sock, ver, path, body, send_only=nil)
-      self.content_length = body.length
+      self.content_length = body.respond_to?(:bytesize) ? body.bytesize : body.length
       delete 'Transfer-Encoding'
       supply_default_content_type
       write_header(sock, ver, path) unless send_only == :body
-      sock.write(body)              unless send_only == :header
+      sock.write(body && body.to_s) unless send_only == :header
     end
 
     def send_request_with_body_stream(sock, ver, path, f, send_only=nil)
+      # KD: Fix 'content-length': it must not be greater than a piece of file left to be read.
+      # Otherwise the connection may behave like crazy causing 4xx or 5xx responses
+      #
+      # Only do this helpful thing if the stream responds to :pos (it may be something
+      # that responds to :read and :size but not :pos).
+      if f.respond_to?(:pos)
+        file_size           = f.respond_to?(:lstat) ? f.lstat.size : f.size
+        bytes_to_read       = [ file_size - f.pos, self.content_length.to_i ].sort.first
+        self.content_length = bytes_to_read
+      end
+
       unless content_length() or chunked?
         raise ArgumentError,
             "Content-Length not given and Transfer-Encoding is not `chunked'"
       end
+      bytes_to_read ||= content_length()
       supply_default_content_type
       write_header(sock, ver, path) unless send_only == :body
       unless send_only == :header
@@ -112,8 +125,14 @@ module Net
           end
           sock.write "0\r\n\r\n"
         else
-          while s = f.read(@@local_read_size)
+          # KD: When we read/write over file EOF it sometimes make the connection unstable
+          read_size = [ @@local_read_size, bytes_to_read ].sort.first
+          while s = f.read(read_size)
             sock.write s
+            # Make sure we do not read over EOF or more than expected content-length
+            bytes_to_read -= read_size
+            break if bytes_to_read <= 0
+            read_size = bytes_to_read if bytes_to_read < read_size
           end
         end
       end
@@ -144,6 +163,7 @@ module Net
         req.exec @socket, @curr_http_version, edit_path(req.path), send_only
         begin
           res = HTTPResponse.read_new(@socket)
+          res.decode_content = req.decode_content if RUBY_VERSION > '2.0'
           # if we expected 100-continue then send a body
           if res.is_a?(HTTPContinue) && send_only && req['content-length'].to_i > 0
             req.exec @socket, @curr_http_version, edit_path(req.path), :body

data/lib/base/support.rb

@@ -0,0 +1,109 @@
+  # These are ActiveSupport-;like extensions to do a few handy things in the gems
+  # Derived from ActiveSupport, so the AS copyright notice applies:
+  #
+  #
+  #
+  # Copyright (c) 2005 David Heinemeier Hansson
+  #
+  # 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.
+  #++
+  #
+  #
+  class String #:nodoc:
+
+    # Constantize tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    #
+    # Examples
+    #   "Module".constantize #=> Module
+    #   "Class".constantize #=> Class
+    def right_constantize()
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+        raise NameError, "#{self.inspect} is not a valid constant name!"
+      end
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+
+    def right_camelize()
+      self.dup.split(/_/).map{ |word| word.capitalize }.join('')
+    end
+
+  end
+
+
+  class Object #:nodoc:
+    # "", "   ", nil, [], and {} are blank
+    def right_blank?
+      if respond_to?(:empty?) && respond_to?(:strip)
+        empty? or strip.empty?
+      elsif respond_to?(:empty?)
+        empty?
+      else
+        !self
+      end
+    end
+  end
+
+  class NilClass #:nodoc:
+    def right_blank?
+      true
+    end
+  end
+
+  class FalseClass #:nodoc:
+    def right_blank?
+      true
+    end
+  end
+
+  class TrueClass #:nodoc:
+    def right_blank?
+      false
+    end
+  end
+
+  class Array #:nodoc:
+    alias_method :right_blank?, :empty?
+  end
+
+  class Hash #:nodoc:
+    alias_method :right_blank?, :empty?
+
+    # Return a new hash with all keys converted to symbols.
+    def right_symbolize_keys
+      inject({}) do |options, (key, value)|
+        options[key.to_sym] = value
+        options
+      end
+    end
+  end
+
+  class String #:nodoc:
+    def right_blank?
+      empty? || strip.empty?
+    end
+  end
+
+  class Numeric #:nodoc:
+    def right_blank?
+      false
+    end
+  end

data/lib/base/version.rb

@@ -0,0 +1,32 @@
+#--  -*- mode: ruby; encoding: utf-8 -*-
+# Copyright: Copyright (c) 2010 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 RightHttpConnection #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1  unless defined?(MAJOR)
+    MINOR = 5  unless defined?(MINOR)
+    TINY  = 1  unless defined?(TINY)
+
+    STRING = [MAJOR, MINOR, TINY].join('.') unless defined?(STRING)
+  end
+end

data/lib/right_http_connection.rb

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2007-2008 RightScale Inc
+# Copyright (c) 2007-2011 RightScale Inc
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -27,22 +27,12 @@ require "time"
 require "logger"
 
 $:.unshift(File.dirname(__FILE__))
-require "net_fix"
-
-
-module RightHttpConnection #:nodoc:
-  module VERSION #:nodoc:
-    MAJOR = 1
-    MINOR = 2
-    TINY  = 3
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end
-
+require 'base/version'
+require 'base/support'
+require 'base/net_fix'
 
 module Rightscale
- 
+
 =begin rdoc
 HttpConnection maintains a persistent HTTP connection to a remote
 server.  Each instance maintains its own unique connection to the
@@ -75,16 +65,16 @@ the full number of potential reconnects and retries available to
 them.
 =end
 
-  class HttpConnection 
+  class HttpConnection
 
     # Number of times to retry the request after encountering the first error
-    HTTP_CONNECTION_RETRY_COUNT   = 3   
+    HTTP_CONNECTION_RETRY_COUNT   = 3   unless defined?(HTTP_CONNECTION_RETRY_COUNT)
     # Throw a Timeout::Error if a connection isn't established within this number of seconds
-    HTTP_CONNECTION_OPEN_TIMEOUT  = 5   
+    HTTP_CONNECTION_OPEN_TIMEOUT  = 5   unless defined?(HTTP_CONNECTION_OPEN_TIMEOUT)
     # Throw a Timeout::Error if no data have been read on this connnection within this number of seconds
-    HTTP_CONNECTION_READ_TIMEOUT  = 120  
-    # Length of the post-error probationary period during which all requests will fail 
-    HTTP_CONNECTION_RETRY_DELAY   = 15  
+    HTTP_CONNECTION_READ_TIMEOUT  = 120 unless defined?(HTTP_CONNECTION_READ_TIMEOUT)
+    # Length of the post-error probationary period during which all requests will fail
+    HTTP_CONNECTION_RETRY_DELAY   = 15  unless defined?(HTTP_CONNECTION_RETRY_DELAY)
 
     #--------------------
     # class methods
@@ -95,22 +85,28 @@ them.
     @@params[:http_connection_open_timeout] = HTTP_CONNECTION_OPEN_TIMEOUT
     @@params[:http_connection_read_timeout] = HTTP_CONNECTION_READ_TIMEOUT
     @@params[:http_connection_retry_delay]  = HTTP_CONNECTION_RETRY_DELAY
-   
+
     # Query the global (class-level) parameters:
-    # 
-    #  :user_agent => 'www.HostName.com'    # String to report as HTTP User agent 
+    #
+    #  :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.
+    #  :fail_if_ca_mismatch => Boolean      # If ca_file is set and the server certificate doesn't verify, a log line is generated regardless, but normally right_http_connection continues on past the failure.  If this is set, fail to connect in that case.  Defaults to false.
     #  :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.
+    #  :proxy_host => 'hostname'            # hostname of HTTP proxy host to use, default none.
+    #  :proxy_port => port                  # port of HTTP proxy host to use, default none.
+    #  :proxy_username => 'username'        # username to use for proxy authentication, default none.
+    #  :proxy_password => 'password'        # password to use for proxy authentication, default none.
     #  :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
+    #  :raise_on_timeout                    # do not perform a retry if timeout is received (false by default)
     def self.params
       @@params
     end
-   
+
     # Set the global (class-level) parameters
     def self.params=(params)
       @@params = params
@@ -125,30 +121,65 @@ them.
     attr_accessor :logger
 
      # Params hash:
-     #  :user_agent => 'www.HostName.com'    # String to report as HTTP User agent 
+     #  :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.
+     #  :fail_if_ca_mismatch => Boolean      # If ca_file is set and the server certificate doesn't verify, a log line is generated regardless, but normally right_http_connection continues on past the failure.  If this is set, fail to connect in that case.  Defaults to false.
      #  :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.
+     #  :proxy_host => 'hostname'            # hostname of HTTP proxy host to use, default none.
+     #  :proxy_port => port                  # port of HTTP proxy host to use, default none.
+     #  :proxy_username => 'username'        # username to use for proxy authentication, default none.
+     #  :proxy_password => 'password'        # password to use for proxy authentication, default none.
      #  :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]
-     #
+     #  :raise_on_timeout                    # do not perform a retry if timeout is received (false by default)
     def initialize(params={})
       @params = params
+
+      #set up logging first
+      @logger = get_param(:logger) ||
+                (RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)) ||
+                Logger.new(STDOUT)
+
+      env_proxy_host, env_proxy_port, env_proxy_username, env_proxy_password = get_proxy_info_for_env if ENV['HTTP_PROXY']
+
       @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]
+      @params[:proxy_host] ||= @@params[:proxy_host] || env_proxy_host
+      @params[:proxy_port] ||= @@params[:proxy_port] || env_proxy_port
+      @params[:proxy_username] ||= @@params[:proxy_username] || env_proxy_username
+      @params[:proxy_password] ||= @@params[:proxy_password] || env_proxy_password
+
       @http   = nil
       @server = nil
-      @logger = get_param(:logger) || 
-                (RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)) ||
-                Logger.new(STDOUT)
+      #--------------
+      # Retry state - Keep track of errors on a per-server basis
+      #--------------
+      @state = {}  # retry state indexed by server: consecutive error count, error time, and error
+                                                                                                                                                                                                          
+      @eof   = {}
+    end
+
+    def get_proxy_info_for_env
+      parsed_uri = URI.parse(ENV['HTTP_PROXY'])
+      if parsed_uri.scheme.to_s.downcase == 'http'
+        return parsed_uri.host, parsed_uri.port, parsed_uri.user, parsed_uri.password
+      else
+        @logger.warn "Invalid protocol in ENV['HTTP_PROXY'] URI = #{ENV['HTTP_PROXY'].inspect} expecting 'http' got #{parsed_uri.scheme.inspect}"
+        return
+      end
+    rescue Exception => e
+      @logger.warn "Error parsing ENV['HTTP_PROXY'] with exception: #{e.message}"
+      return
     end
+    private :get_proxy_info_for_env
 
-    def get_param(name)
-      @params[name] || @@params[name]
+    def get_param(name, custom_options={})
+      custom_options [name] || @params[name] || @@params[name]
     end
 
     # Query for the maximum size (in bytes) of a single read from the underlying
@@ -164,7 +195,7 @@ them.
     def socket_read_size=(newsize)
       Net::BufferedIO.socket_read_size=(newsize)
     end
- 
+
     # 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.
@@ -180,81 +211,78 @@ them.
     end
 
   private
-    #--------------
-    # Retry state - Keep track of errors on a per-server basis
-    #--------------
-    @@state = {}  # retry state indexed by server: consecutive error count, error time, and error
-    @@eof   = {}
 
     # number of consecutive errors seen for server, 0 all is ok
     def error_count
-      @@state[@server] ? @@state[@server][:count] : 0
+      @state[@server] ? @state[@server][:count] : 0
     end
-    
+
     # time of last error for server, nil if all is ok
     def error_time
-      @@state[@server] && @@state[@server][:time]
+      @state[@server] && @state[@server][:time]
     end
-    
+
     # message for last error for server, "" if all is ok
     def error_message
-      @@state[@server] ? @@state[@server][:message] : ""
+      @state[@server] ? @state[@server][:message] : ""
     end
-    
+
     # add an error for a server
-    def error_add(message)
-      @@state[@server] = { :count => error_count+1, :time => Time.now, :message => message }
+    def error_add(error)
+      message = error
+      message = "#{error.class.name}: #{error.message}" if error.is_a?(Exception)
+      @state[@server] = { :count => error_count+1, :time => Time.now, :message => message }
     end
-    
+
     # reset the error state for a server (i.e. a request succeeded)
     def error_reset
-      @@state.delete(@server)
+      @state.delete(@server)
     end
-    
+
     # Error message stuff...
     def banana_message
-      return "#{@server} temporarily unavailable: (#{error_message})"
+      return "#{@protocol}://#{@server}:#{@port} temporarily unavailable: (#{error_message})"
     end
 
     def err_header
       return "#{self.class.name} :"
     end
-    
+
       # Adds new EOF timestamp.
       # Returns the number of seconds to wait before new conection retry:
       #  0.5, 1, 2, 4, 8
     def add_eof
-      (@@eof[@server] ||= []).unshift Time.now
-      0.25 * 2 ** @@eof[@server].size
+      (@eof[@server] ||= []).unshift Time.now
+      0.25 * 2 ** @eof[@server].size
     end
 
       # Returns first EOF timestamp or nul if have no EOFs being tracked.
     def eof_time
-      @@eof[@server] && @@eof[@server].last
+      @eof[@server] && @eof[@server].last
     end
-    
+
       # Returns true if we are receiving EOFs during last @params[:http_connection_retry_delay] seconds
       # and there were no successful response from server
     def raise_on_eof_exception?
-      @@eof[@server].blank? ? false : ( (Time.now.to_i-@params[:http_connection_retry_delay]) > @@eof[@server].last.to_i )
-    end 
-    
+      @eof[@server].nil? ? false : ( (Time.now.to_i-@params[:http_connection_retry_delay]) > @eof[@server].last.to_i )
+    end
+
       # Reset a list of EOFs for this server.
       # This is being called when we have got an successful response from server.
     def eof_reset
-      @@eof.delete(@server)
+      @eof.delete(@server)
     end
-    
-    # Detects if an object is 'streamable' - can we read from it, and can we know the size?  
+
+    # Detects if an object is 'streamable' - can we read from it, and can we know the size?
     def setup_streaming(request)
       if(request.body && request.body.respond_to?(:read))
         body = request.body
-        request.content_length = body.respond_to?(:lstat) ? body.lstat.size : body.size 
+        request.content_length = body.respond_to?(:lstat) ? body.lstat.size : body.size
         request.body_stream = request.body
         true
       end
     end
-    
+
     def get_fileptr_offset(request_params)
       request_params[:request].body.pos
     rescue Exception => e
@@ -262,7 +290,7 @@ them.
       # Just return 0 and get on with life.
       0
     end
-    
+
     def reset_fileptr_offset(request, offset = 0)
       if(request.body_stream && request.body_stream.respond_to?(:pos))
         begin
@@ -272,38 +300,88 @@ them.
                              " -- #{err_header} #{e.inspect}")
           raise e
         end
-      end  
+      end
     end
 
+    SECURITY_PARAMS = [:cert, :key, :cert_file, :key_file, :ca_file]
+
     # Start a fresh connection. The object closes any existing connection and
     # opens a new one.
     def start(request_params)
       # close the previous if exists
       finish
       # create new connection
-      @server   = request_params[:server]
-      @port     = request_params[:port]
-      @protocol = request_params[:protocol]
+      @server         = request_params[:server]
+      @port           = request_params[:port]
+      @protocol       = request_params[:protocol]
+      @proxy_host     = request_params[:proxy_host]
+      @proxy_port     = request_params[:proxy_port]
+      @proxy_username = request_params[:proxy_username]
+      @proxy_password = request_params[:proxy_password]
       
+      SECURITY_PARAMS.each do |param_name|
+        @params[param_name] = request_params[param_name]
+      end
+
       @logger.info("Opening new #{@protocol.upcase} connection to #@server:#@port")
-      @http = Net::HTTP.new(@server, @port)
-      @http.open_timeout = @params[:http_connection_open_timeout]
-      @http.read_timeout = @params[:http_connection_read_timeout]
-      
+
+      @logger.info("Connecting to proxy #{@proxy_host}:#{@proxy_port} with username" +
+                   " #{@proxy_username.inspect}") unless @proxy_host.nil?
+
+      @http = Net::HTTP.new(@server, @port, @proxy_host, @proxy_port, @proxy_username,
+                            @proxy_password)
+      @http.open_timeout = get_param(:http_connection_open_timeout, request_params)
+      @http.read_timeout = get_param(:http_connection_read_timeout, request_params)
+
       if @protocol == 'https'
         verifyCallbackProc = Proc.new{ |ok, x509_store_ctx|
+          # List of error codes: http://www.openssl.org/docs/apps/verify.html
           code = x509_store_ctx.error
           msg = x509_store_ctx.error_string
-            #debugger
-          @logger.warn("##### #{@server} certificate verify failed: #{msg}") unless code == 0
-          true
+          if request_params[:fail_if_ca_mismatch] && code != 0
+            false
+          else
+            true
+          end
         }
         @http.use_ssl = true
+
         ca_file = get_param(:ca_file)
-        if ca_file
-          @http.verify_mode     = OpenSSL::SSL::VERIFY_PEER
+        if ca_file && File.exists?(ca_file)
+          # Documentation for 'http.rb':
+          # : verify_mode, verify_mode=((|mode|))
+          #    Sets the flags for server the certification verification at
+          #    beginning of SSL/TLS session.
+          #    OpenSSL::SSL::VERIFY_NONE or OpenSSL::SSL::VERIFY_PEER is acceptable.
+          #
+          # KHRVI: looks like the constant VERIFY_FAIL_IF_NO_PEER_CERT is not acceptable
           @http.verify_callback = verifyCallbackProc
-          @http.ca_file         = ca_file 
+          @http.ca_file= ca_file
+          @http.verify_mode = get_param(:use_server_auth) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+          # The depth count is 'level 0:peer certificate', 'level 1: CA certificate', 'level 2: higher level CA certificate', and so on.
+          # Setting the maximum depth to 2 allows the levels 0, 1, and 2. The default depth limit is 9, allowing for the peer certificate and additional 9 CA certificates.
+          @http.verify_depth    = 9
+        else
+          @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        
+        # CERT
+        cert_file = get_param(:cert_file, request_params)
+        cert      = File.read(cert_file) if cert_file && File.exists?(cert_file)
+        cert    ||= get_param(:cert, request_params)
+        # KEY
+        key_file  = get_param(:key_file,  request_params)
+        key       = File.read(key_file) if key_file && File.exists?(key_file)
+        key     ||= get_param(:key,  request_params)
+        if cert && key
+          begin
+            @http.verify_callback = verifyCallbackProc
+            @http.cert = OpenSSL::X509::Certificate.new(cert)
+            @http.key  = OpenSSL::PKey::RSA.new(key)
+          rescue OpenSSL::PKey::RSAError, OpenSSL::X509::CertificateError => e
+            @logger.error "##### Error loading SSL client cert or key: #{e.message} :: backtrace #{e.backtrace}"
+            raise e
+          end
         end
       end
       # open connection
@@ -312,55 +390,82 @@ them.
 
   public
 
-=begin rdoc    
+=begin rdoc
     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 
+     :port     => '80'                 # Port of HTTP server
+     :protocol => 'https'              # http and https are supported on any port
      :request  => 'requeststring'      # Fully-formed HTTP request to make
+     :proxy_host => 'hostname'         # hostname of HTTP proxy host to use, default none.
+     :proxy_port => port               # port of HTTP proxy host to use, default none.
+     :proxy_username => 'username'     # username to use for proxy authentication, default none.
+     :proxy_password => 'password'     # password to use for proxy authentication, default none.
+
+     :raise_on_timeout                 # do not perform a retry if timeout is received (false by default)
+     :http_connection_retry_count
+     :http_connection_open_timeout
+     :http_connection_read_timeout
+     :http_connection_retry_delay
+     :user_agent
+     :exception
 
     Raises RuntimeError, Interrupt, and params[:exception] (if specified in new).
-    
+
 =end
     def request(request_params, &block)
+      current_params = @params.merge(request_params)
+      exception = get_param(:exception, current_params) || RuntimeError
+
+      # Re-establish the connection if any of auth params has changed
+      same_auth_params_as_before = SECURITY_PARAMS.select do |param|
+        request_params[param] != get_param(param)
+      end.empty?
+
       # 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)
+      mypos = get_fileptr_offset(current_params)
       loop do
+
+        current_params[:protocol] ||= (current_params[:port] == 443 ? 'https' : 'http')
+        # (re)open connection to server if none exists or params has changed
+        same_server_as_before = @server   == current_params[:server]   &&
+                                @port     == current_params[:port]     &&
+                                @protocol == current_params[:protocol] &&
+                                same_auth_params_as_before
+
         # 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
+        # (skip this step if the endpoint has changed)
+        if error_count > current_params[:http_connection_retry_count]            &&
+           error_time  + current_params[:http_connection_retry_delay] > Time.now &&
+           same_server_as_before
+
           # 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
+                      "-- error count: #{error_count}, error age: #{Time.now.to_i - error_time.to_i}")
           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')
-          # (re)open connection to server if none exists or params has changed
-          unless @http          && 
+          request = current_params[:request]
+          request['User-Agent'] = get_param(:user_agent, current_params) || ''
+          unless @http          &&
                  @http.started? &&
-                 @server   == request_params[:server] &&
-                 @port     == request_params[:port]   &&
-                 @protocol == request_params[:protocol]
-            start(request_params)
+                 same_server_as_before
+            same_auth_params_as_before = true
+            start(current_params)
           end
-          
-          # get response and return it
-          request  = request_params[:request]
-          request['User-Agent'] = get_param(:user_agent) || ''
 
           # Detect if the body is a streamable object like a file or socket.  If so, stream that
           # bad boy.
           setup_streaming(request)
+          # update READ_TIMEOUT value (it can be passed with request_params hash)
+          @http.read_timeout = get_param(:http_connection_read_timeout, current_params)
           response = @http.request(request, &block)
-          
+
           error_reset
           eof_reset
           return response
@@ -373,51 +478,64 @@ them.
         # '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
+          finish(e.message)
           
+          @logger.debug("#{err_header} server #{@server} closed connection")
+
             # 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}")  
+            @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)')
+          end
+        rescue ArgumentError => e
+          finish(e.message)
+          
+          if 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')
+          else
+            raise e
+          end
+
+        rescue Timeout::Error, SocketError, SystemCallError, Interrupt => e  # See comment at bottom for the list of errors seen...
+          finish(e.message)
+          if e.is_a?(Errno::ETIMEDOUT) || e.is_a?(Timeout::Error)
+            # Omit retries if it was explicitly requested
+            # #6481:
+            # ... When creating a resource in EC2 (instance, volume, snapshot, etc) it is undetermined what happened if the call times out.
+            # The resource may or may not have been created in EC2. Retrying the call may cause multiple resources to be created...
+            raise exception.new("#{e.class.name}: #{e.message}") if current_params[:raise_on_timeout]
+          elsif e.is_a?(Interrupt)
+            # if ctrl+c is pressed - we have to reraise exception to terminate proggy
+            @logger.debug( "#{err_header} request to server #{@server} interrupted by ctrl-c")
+            raise e
           end
           # oops - we got a banana: log it
-          error_add(e.message)
+          error_add(e)
           @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
 
     def finish(reason = '')
       if @http && @http.started?
-        reason = ", reason: '#{reason}'" unless reason.blank?
+        reason = ", reason: '#{reason}'" unless reason.empty?
         @logger.info("Closing #{@http.use_ssl? ? 'HTTPS' : 'HTTP'} connection to #{@http.address}:#{@http.port}#{reason}")
-        @http.finish 
+        @http.finish
       end
+    ensure
+      @http = nil
     end
 
   # Errors received during testing:
@@ -430,6 +548,6 @@ them.
   #  #<Errno::ECONNRESET: Connection reset by peer>
   #  #<OpenSSL::SSL::SSLError: SSL_write:: bad write retry>
   end
-  
+
 end