right_http_connection 1.2.4 → 1.5.1

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,19 +27,9 @@ require "time"
 require "logger"
 
 $:.unshift(File.dirname(__FILE__))
-require "net_fix"
-
-
-module RightHttpConnection #:nodoc:
-  module VERSION #:nodoc:
-    MAJOR = 1
-    MINOR = 2
-    TINY  = 4
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end
-
+require 'base/version'
+require 'base/support'
+require 'base/net_fix'
 
 module Rightscale
 
@@ -78,13 +68,13 @@ them.
   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
+    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
+    HTTP_CONNECTION_RETRY_DELAY   = 15  unless defined?(HTTP_CONNECTION_RETRY_DELAY)
 
     #--------------------
     # class methods
@@ -100,13 +90,19 @@ them.
     #
     #  :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
@@ -127,28 +123,63 @@ them.
      # 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.
+     #  :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_param(name)
-      @params[name] || @@params[name]
+    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, custom_options={})
+      custom_options [name] || @params[name] || @@params[name]
     end
 
     # Query for the maximum size (in bytes) of a single read from the underlying
@@ -180,40 +211,37 @@ 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
@@ -224,25 +252,25 @@ them.
       # 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 )
+      @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?
@@ -275,35 +303,85 @@ them.
       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
@@ -320,45 +398,72 @@ them.
      :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
           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
+          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
 
           # 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
@@ -376,12 +481,12 @@ them.
 
         # EOFError means the server closed the connection on us.
         rescue EOFError => e
+          finish(e.message)
+          
           @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
@@ -390,34 +495,47 @@ them.
             # 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)')
+        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
       end
+    ensure
+      @http = nil
     end
 
   # Errors received during testing:

data/right_http_connection.gemspec

@@ -0,0 +1,63 @@
+#--  -*- 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.
+#++
+
+require 'rubygems'
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'base', 'version'))
+
+Gem::Specification.new do |spec|
+  spec.name = 'right_http_connection'
+  spec.rubyforge_project = 'rightscale'
+  spec.version = RightHttpConnection::VERSION::STRING
+  spec.authors = ['RightScale, Inc.']
+  spec.email = 'rubygems@rightscale.com'
+  spec.homepage = 'http://rightscale.rubyforge.org/'
+  spec.summary = 'RightScale\'s robust HTTP/S connection module'
+  spec.has_rdoc = true
+  spec.rdoc_options = ['--quiet', '--main', 'README.txt', '--title',
+                       'right_http_connection documentation', '--opname',
+                       'index.html', '--line-numbers', '--inline-source']
+  spec.extra_rdoc_files = ['README.txt']
+  spec.required_ruby_version = '>= 1.8.7'
+  spec.require_path = 'lib'
+
+  spec.add_development_dependency('rake', '< 12')
+  spec.add_development_dependency('rspec', "~> 2.3")
+  spec.add_development_dependency('cucumber', "~> 0.8")
+  spec.add_development_dependency('flexmock', "~> 0.8.11")
+  spec.add_development_dependency('trollop', "~> 1.16")
+
+  spec.description = <<-EOF
+Rightscale::HttpConnection is a robust HTTP/S library.  It implements a retry
+algorithm for low-level network errors.
+
+== FEATURES:
+
+- provides put/get streaming
+- does configurable retries on connect and read timeouts, DNS failures, etc.
+- HTTPS certificate checking
+EOF
+
+  candidates = Dir.glob('{lib,spec}/**/*') + ['History.txt', 'Manifest.txt', 'README.txt', 'Rakefile',
+                                              'right_http_connection.gemspec']
+  spec.files = candidates.sort
+end