Class: Net::HTTP::Persistent

510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525

# File 'lib/bundler/vendor/net/http/persistent.rb', line 510

def cleanup(generation, thread = Thread.current,
            generation_key = @generation_key) # :nodoc:
  timeouts = thread[@timeout_key]

  (0...generation).each do |old_generation|
    next unless thread[generation_key]

    conns = thread[generation_key].delete old_generation

    conns.each_value do |conn|
      finish conn, thread

      timeouts.delete conn.object_id if timeouts
    end if conns
  end
end

692
693
694

# File 'lib/bundler/vendor/net/http/persistent.rb', line 692

def connection_close? header
  header.connection_close?
end

530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585

# File 'lib/bundler/vendor/net/http/persistent.rb', line 530

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
    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
  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
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

699
700
701

# File 'lib/bundler/vendor/net/http/persistent.rb', line 699

def connection_keep_alive? header
  header.connection_keep_alive?
end

591
592
593
594
595
596
597
598
599

# File 'lib/bundler/vendor/net/http/persistent.rb', line 591

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

604
605
606

# File 'lib/bundler/vendor/net/http/persistent.rb', line 604

def escape str
  CGI.escape str if str
end

612
613
614
615
616
617
618
619

# File 'lib/bundler/vendor/net/http/persistent.rb', line 612

def expired? connection
  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

642
643
644
645
646
647
648
649

# File 'lib/bundler/vendor/net/http/persistent.rb', line 642

def finish connection, thread = Thread.current
  if requests = thread[@request_key] then
    requests.delete connection.object_id
  end

  connection.finish
rescue IOError
end

651
652
653
654
655
656
657
658
659
660
661

# File 'lib/bundler/vendor/net/http/persistent.rb', line 651

def http_class # :nodoc:
  if RUBY_VERSION > '2.0' then
    Net::HTTP
  elsif [:Artifice, :FakeWeb, :WebMock].any? { |klass|
           Object.const_defined?(klass)
        } or not @reuse_ssl_sessions then
      Net::HTTP
  else
    Net::HTTP::Persistent::SSLReuse
  end
end

666
667
668

# File 'lib/bundler/vendor/net/http/persistent.rb', line 666

def http_version uri
  @http_versions["#{uri.host}:#{uri.port}"]
end

673
674
675
676
677
678
679

# File 'lib/bundler/vendor/net/http/persistent.rb', line 673

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

723
724
725
726
727

# File 'lib/bundler/vendor/net/http/persistent.rb', line 723

def max_age # :nodoc:
  return Time.now + 1 unless @idle_timeout

  Time.now - @idle_timeout
end

732
733
734

# File 'lib/bundler/vendor/net/http/persistent.rb', line 732

def normalize_uri uri
  (uri =~ /^https?:/) ? uri : "http://#{uri}"
end

747
748
749
750
751

# File 'lib/bundler/vendor/net/http/persistent.rb', line 747

def pipeline uri, requests, &block # :yields: responses
  connection = connection_for uri

  connection.pipeline requests, &block
end

779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806

# File 'lib/bundler/vendor/net/http/persistent.rb', line 779

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,
      @proxy_uri.user,
      @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

853
854
855
856
857
858
859
860
861
862
863

# File 'lib/bundler/vendor/net/http/persistent.rb', line 853

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

826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848

# File 'lib/bundler/vendor/net/http/persistent.rb', line 826

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

868
869
870

# File 'lib/bundler/vendor/net/http/persistent.rb', line 868

def reconnect
  @generation += 1
end

875
876
877

# File 'lib/bundler/vendor/net/http/persistent.rb', line 875

def reconnect_ssl
  @ssl_generation += 1
end

907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977

# File 'lib/bundler/vendor/net/http/persistent.rb', line 907

def request uri, req = nil, &block
  retried      = false
  bad_response = false

  req = Net::HTTP::Get.new uri.request_uri unless req

  @headers.each do |pair|
    req.add_field(*pair)
  end

  if uri.user or uri.password
    req.basic_auth uri.user, uri.password
  end

  @override_headers.each do |name, value|
    req[name] = value
  end

  unless req['Connection'] then
    req.add_field 'Connection', 'keep-alive'
    req.add_field 'Keep-Alive', @keep_alive
  end

  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 IOError, EOFError, Timeout::Error,
         Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE,
         Errno::EINVAL, OpenSSL::SSL::SSLError => e

    if retried or not can_retry? req
      due_to = "(due to #{e.message} - #{e.class})"
      message = error_message connection

      finish connection

      raise Error, "too many connection resets #{due_to} #{message}"
    end

    reset connection

    retried = true
    retry
  ensure
    Thread.current[@timeout_key][connection_id] = Time.now
  end

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

  response
end

882
883
884
885
886
887
888
889
890
891
892
893

# File 'lib/bundler/vendor/net/http/persistent.rb', line 882

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
  raise Error, "connection refused: #{connection.address}:#{connection.port}"
rescue Errno::EHOSTDOWN
  raise Error, "host down: #{connection.address}:#{connection.port}"
end

992
993
994
995
996
997
998
999
1000
1001

# File 'lib/bundler/vendor/net/http/persistent.rb', line 992

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

1013
1014
1015
1016
1017
1018
1019

# File 'lib/bundler/vendor/net/http/persistent.rb', line 1013

def shutdown_in_all_threads
  Thread.list.each do |thread|
    shutdown thread
  end

  nil
end

1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076

# File 'lib/bundler/vendor/net/http/persistent.rb', line 1024

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

1082
1083
1084

# File 'lib/bundler/vendor/net/http/persistent.rb', line 1082

def ssl_cleanup generation # :nodoc:
  cleanup generation, Thread.current, @ssl_generation_key
end

624
625
626
627
628
629
630
631
632
633
634
635
636
637

# File 'lib/bundler/vendor/net/http/persistent.rb', line 624

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