Bundler::Persistent::Net::HTTP::Persistent

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 243
def self.detect_idle_timeout uri, max = 10
  uri = URI uri unless URI::Generic === uri
  uri += '/'

  req = Net::HTTP::Head.new uri.request_uri

  http = new 'net-http-persistent detect_idle_timeout'

  connection = http.connection_for uri

  sleep_time = 0

  loop do
    response = connection.request req

    $stderr.puts "HEAD #{uri} => #{response.code}" if $DEBUG

    unless Net::HTTPOK === response then
      raise Error, "bad response code #{response.code} detecting idle timeout"
    end

    break if sleep_time >= max

    sleep_time += 1

    $stderr.puts "sleeping #{sleep_time}" if $DEBUG
    sleep sleep_time
  end
rescue
  # ignore StandardErrors, we've probably found the idle timeout.
ensure
  http.shutdown

  return sleep_time unless $!
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 482
def initialize name = nil, proxy = nil
  @name = name

  @debug_output     = nil
  @proxy_uri        = nil
  @no_proxy         = []
  @headers          = {}
  @override_headers = {}
  @http_versions    = {}
  @keep_alive       = 30
  @open_timeout     = nil
  @read_timeout     = nil
  @idle_timeout     = 5
  @max_requests     = nil
  @socket_options   = []

  @socket_options << [Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1] if
    Socket.const_defined? :TCP_NODELAY

  key = ['net_http_persistent', name].compact
  @generation_key     = [key, 'generations'    ].join('_').intern
  @ssl_generation_key = [key, 'ssl_generations'].join('_').intern
  @request_key        = [key, 'requests'       ].join('_').intern
  @timeout_key        = [key, 'timeouts'       ].join('_').intern

  @certificate        = nil
  @ca_file            = nil
  @private_key        = nil
  @ssl_version        = nil
  @verify_callback    = nil
  @verify_mode        = nil
  @cert_store         = nil

  @generation         = 0 # incremented when proxy URI changes
  @ssl_generation     = 0 # incremented when SSL session variables change

  if HAVE_OPENSSL then
    @verify_mode        = OpenSSL::SSL::VERIFY_PEER
    @reuse_ssl_sessions = OpenSSL::SSL.const_defined? :Session
  end

  @retry_change_requests = false

  @ruby_1 = RUBY_VERSION < '2'
  @retried_on_ruby_2 = !@ruby_1

  self.proxy = proxy if proxy
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 546
def ca_file= file
  @ca_file = file

  reconnect_ssl
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 761
def can_retry? req, retried_on_ruby_2 = false
  return @retry_change_requests && !idempotent?(req) if retried_on_ruby_2

  @retry_change_requests || idempotent?(req)
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 556
def cert_store= store
  @cert_store = store

  reconnect_ssl
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 534
def certificate= certificate
  @certificate = certificate

  reconnect_ssl
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 771
def connection_close? header
  header.connection_close?
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 588
def connection_for uri
  Thread.current[@generation_key]     ||= Hash.new { |h,k| h[k] = {} }
  Thread.current[@ssl_generation_key] ||= Hash.new { |h,k| h[k] = {} }
  Thread.current[@request_key]        ||= Hash.new 0
  Thread.current[@timeout_key]        ||= Hash.new EPOCH

  use_ssl = uri.scheme.downcase == 'https'

  if use_ssl then
    raise Bundler::Persistent::Net::HTTP::Persistent::Error, 'OpenSSL is not available' unless
      HAVE_OPENSSL

    ssl_generation = @ssl_generation

    ssl_cleanup ssl_generation

    connections = Thread.current[@ssl_generation_key][ssl_generation]
  else
    generation = @generation

    cleanup generation

    connections = Thread.current[@generation_key][generation]
  end

  net_http_args = [uri.host, uri.port]
  connection_id = net_http_args.join ':'

  if @proxy_uri and not proxy_bypass? uri.host, uri.port then
    connection_id << @proxy_connection_id
    net_http_args.concat @proxy_args
  else
    net_http_args.concat [nil, nil, nil, nil]
  end

  connection = connections[connection_id]

  unless connection = connections[connection_id] then
    connections[connection_id] = http_class.new(*net_http_args)
    connection = connections[connection_id]
    ssl connection if use_ssl
  else
    reset connection if expired? connection
  end

  start connection unless connection.started?

  connection.read_timeout = @read_timeout if @read_timeout
  connection.keep_alive_timeout = @idle_timeout if @idle_timeout && connection.respond_to?(:keep_alive_timeout=)

  connection
rescue Errno::ECONNREFUSED
  address = connection.proxy_address || connection.address
  port    = connection.proxy_port    || connection.port

  raise Error, "connection refused: #{address}:#{port}"
rescue Errno::EHOSTDOWN
  address = connection.proxy_address || connection.address
  port    = connection.proxy_port    || connection.port

  raise Error, "host down: #{address}:#{port}"
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 778
def connection_keep_alive? header
  header.connection_keep_alive?
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 655
def error_message connection
  requests = Thread.current[@request_key][connection.object_id] - 1 # fixup
  last_use = Thread.current[@timeout_key][connection.object_id]

  age = Time.now - last_use

  "after #{requests} requests on #{connection.object_id}, " \
    "last used #{age} seconds ago"
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 668
def escape str
  CGI.escape str if str
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 684
def expired? connection
  requests = Thread.current[@request_key][connection.object_id]
  return true  if     @max_requests && requests >= @max_requests
  return false unless @idle_timeout
  return true  if     @idle_timeout.zero?

  last_used = Thread.current[@timeout_key][connection.object_id]

  Time.now - last_used > @idle_timeout
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 716
def finish connection, thread = Thread.current
  if requests = thread[@request_key] then
    requests.delete connection.object_id
  end

  connection.finish
rescue IOError
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 740
def http_version uri
  @http_versions["#{uri.host}:#{uri.port}"]
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 747
def idempotent? req
  case req
  when Net::HTTP::Delete, Net::HTTP::Get, Net::HTTP::Head,
       Net::HTTP::Options, Net::HTTP::Put, Net::HTTP::Trace then
    true
  end
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 811
def normalize_uri uri
  (uri =~ /^https?:/) ? uri : "http://#{uri}"
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 826
def pipeline uri, requests, &block # :yields: responses
  connection = connection_for uri

  connection.pipeline requests, &block
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 835
def private_key= key
  @private_key = key

  reconnect_ssl
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 858
def proxy= proxy
  @proxy_uri = case proxy
               when :ENV      then proxy_from_env
               when URI::HTTP then proxy
               when nil       then # ignore
               else raise ArgumentError, 'proxy must be :ENV or a URI::HTTP'
               end

  @no_proxy.clear

  if @proxy_uri then
    @proxy_args = [
      @proxy_uri.host,
      @proxy_uri.port,
      unescape(@proxy_uri.user),
      unescape(@proxy_uri.password),
    ]

    @proxy_connection_id = [nil, *@proxy_args].join ':'

    if @proxy_uri.query then
      @no_proxy = CGI.parse(@proxy_uri.query)['no_proxy'].join(',').downcase.split(',').map { |x| x.strip }.reject { |x| x.empty? }
    end
  end

  reconnect
  reconnect_ssl
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 932
def proxy_bypass? host, port
  host = host.downcase
  host_port = [host, port].join ':'

  @no_proxy.each do |name|
    return true if host[-name.length, name.length] == name or
       host_port[-name.length, name.length] == name
  end

  false
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 905
def proxy_from_env
  env_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']

  return nil if env_proxy.nil? or env_proxy.empty?

  uri = URI normalize_uri env_proxy

  env_no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']

  # '*' is special case for always bypass
  return nil if env_no_proxy == '*'

  if env_no_proxy then
    uri.query = "no_proxy=#{escape(env_no_proxy)}"
  end

  unless uri.user or uri.password then
    uri.user     = escape ENV['http_proxy_user'] || ENV['HTTP_PROXY_USER']
    uri.password = escape ENV['http_proxy_pass'] || ENV['HTTP_PROXY_PASS']
  end

  uri
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 947
def reconnect
  @generation += 1
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 954
def reconnect_ssl
  @ssl_generation += 1
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 990
def request uri, req = nil, &block
  retried      = false
  bad_response = false

  req = request_setup req || uri

  connection = connection_for uri
  connection_id = connection.object_id

  begin
    Thread.current[@request_key][connection_id] += 1
    response = connection.request req, &block

    if connection_close?(req) or
       (response.http_version <= '1.0' and
        not connection_keep_alive?(response)) or
       connection_close?(response) then
      connection.finish
    end
  rescue Net::HTTPBadResponse => e
    message = error_message connection

    finish connection

    raise Error, "too many bad responses #{message}" if
      bad_response or not can_retry? req

    bad_response = true
    retry
  rescue *RETRIED_EXCEPTIONS => e # retried on ruby 2
    request_failed e, req, connection if
      retried or not can_retry? req, @retried_on_ruby_2

    reset connection

    retried = true
    retry
  rescue Errno::EINVAL, Errno::ETIMEDOUT => e # not retried on ruby 2
    request_failed e, req, connection if retried or not can_retry? req

    reset connection

    retried = true
    retry
  rescue Exception => e
    finish connection

    raise
  ensure
    Thread.current[@timeout_key][connection_id] = Time.now
  end

  @http_versions["#{uri.host}:#{uri.port}"] ||= response.http_version

  response
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 961
def reset connection
  Thread.current[@request_key].delete connection.object_id
  Thread.current[@timeout_key].delete connection.object_id

  finish connection

  start connection
rescue Errno::ECONNREFUSED
  e = Error.new "connection refused: #{connection.address}:#{connection.port}"
  e.set_backtrace $@
  raise e
rescue Errno::EHOSTDOWN
  e = Error.new "host down: #{connection.address}:#{connection.port}"
  e.set_backtrace $@
  raise e
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 1105
def shutdown thread = Thread.current
  generation = reconnect
  cleanup generation, thread, @generation_key

  ssl_generation = reconnect_ssl
  cleanup ssl_generation, thread, @ssl_generation_key

  thread[@request_key] = nil
  thread[@timeout_key] = nil
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 1126
def shutdown_in_all_threads
  Thread.list.each do |thread|
    shutdown thread
  end

  nil
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 1137
  def ssl connection
    connection.use_ssl = true

    connection.ssl_version = @ssl_version if @ssl_version

    connection.verify_mode = @verify_mode

    if OpenSSL::SSL::VERIFY_PEER == OpenSSL::SSL::VERIFY_NONE and
       not Object.const_defined?(:I_KNOW_THAT_OPENSSL_VERIFY_PEER_EQUALS_VERIFY_NONE_IS_WRONG) then
      warn <<-WARNING
                             !!!SECURITY WARNING!!!

The SSL HTTP connection to:

  #{connection.address}:#{connection.port}

                           !!!MAY NOT BE VERIFIED!!!

On your platform your OpenSSL implementation is broken.

There is no difference between the values of VERIFY_NONE and VERIFY_PEER.

This means that attempting to verify the security of SSL connections may not
work.  This exposes you to man-in-the-middle exploits, snooping on the
contents of your connection and other dangers to the security of your data.

To disable this warning define the following constant at top-level in your
application:

  I_KNOW_THAT_OPENSSL_VERIFY_PEER_EQUALS_VERIFY_NONE_IS_WRONG = nil

      WARNING
    end

    if @ca_file then
      connection.ca_file = @ca_file
      connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
      connection.verify_callback = @verify_callback if @verify_callback
    end

    if @certificate and @private_key then
      connection.cert = @certificate
      connection.key  = @private_key
    end

    connection.cert_store = if @cert_store then
                              @cert_store
                            else
                              store = OpenSSL::X509::Store.new
                              store.set_default_paths
                              store
                            end
  end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 1202
def ssl_version= ssl_version
  @ssl_version = ssl_version

  reconnect_ssl
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 698
def start connection
  connection.set_debug_output @debug_output if @debug_output
  connection.open_timeout = @open_timeout if @open_timeout

  connection.start

  socket = connection.instance_variable_get :@socket

  if socket then # for fakeweb
    @socket_options.each do |option|
      socket.io.setsockopt(*option)
    end
  end
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 675
def unescape str
  CGI.unescape str if str
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 1224
def verify_callback= callback
  @verify_callback = callback

  reconnect_ssl
end
            

 
               # File bundler/vendor/net-http-persistent/lib/net/http/persistent.rb, line 1215
def verify_mode= verify_mode
  @verify_mode = verify_mode

  reconnect_ssl
end