Merge #7200

7200: Bump net-http-persistent to 3.1.0 r=deivid-rodriguez a=deivid-rodriguez

### What was the end-user problem that led to this PR?

The problem was that I wanted to propose some changes to this vendored gem, but I found out that we are using an old version of it.

### What was your diagnosis of the problem?

My diagnosis was that we should upgrade.

### What is your fix for the problem, implemented in this PR?

My fix is to upgrade the dependency. Since it's a major update, it required some changes. Also, I had to:

* Add a new artifice task to vendorize new `connection_pool` dependency. This is the main downside of this PR, that the new version adds a dependency on this gem. But this gem is very stable, and rarely changes and releases new versions, as can be seen by its [releases](https://github.com/mperham/connection_pool/releases). 

* Cherry-pick a Windows fix not yet merged into master branch of `net-http-persistent`: drbrain/net-http-persistent#90.

Co-authored-by: David Rodríguez <[email protected]>

Author: bundlerbot

bundler/Rakefile

@@ -251,6 +251,9 @@ rescue Gem::LoadError => e
 
     desc "Vendor a specific version of net-http-persistent"
     task(:"net-http-persistent") { abort msg }
+
+    desc "Vendor a specific version of connection_pool"
+    task(:connection_pool) { abort msg }
   end
 else
   desc "Vendor a specific version of molinillo"
@@ -261,6 +264,9 @@ else
     lib.vendor_lib = "lib/bundler/vendor/molinillo"
   end
 
+  # We currently cherry-pick changes to use `require_relative` internally
+  # instead of regular `require`. They are already in thor's master branch but
+  # still need to be released.
   desc "Vendor a specific version of thor"
   Automatiek::RakeTask.new("thor") do |lib|
     lib.download = { :github => "https://github.com/erikhuda/thor" }
@@ -269,6 +275,9 @@ else
     lib.vendor_lib = "lib/bundler/vendor/thor"
   end
 
+  # We currently cherry-pick changes to use `require_relative` internally
+  # instead of regular `require`. They are already in fileutils' master branch
+  # but still need to be released.
   desc "Vendor a specific version of fileutils"
   Automatiek::RakeTask.new("fileutils") do |lib|
     lib.download = { :github => "https://github.com/ruby/fileutils" }
@@ -277,22 +286,28 @@ else
     lib.vendor_lib = "lib/bundler/vendor/fileutils"
   end
 
+  # Currently `net-http-persistent` and it's dependency `connection_pool` are
+  # vendored separately, but `connection_pool` references inside the vendored
+  # copy of `net-http-persistent` are not properly updated to refer to the
+  # vendored copy of `connection_pool`, so they need to be manually updated.
+  # This will be automated once https://github.com/segiddins/automatiek/pull/3
+  # is included in `automatiek` and we start using the new API for vendoring
+  # subdependencies.
+
   desc "Vendor a specific version of net-http-persistent"
   Automatiek::RakeTask.new("net-http-persistent") do |lib|
     lib.download = { :github => "https://github.com/drbrain/net-http-persistent" }
     lib.namespace = "Net::HTTP::Persistent"
     lib.prefix = "Bundler::Persistent"
     lib.vendor_lib = "lib/bundler/vendor/net-http-persistent"
+  end
 
-    mixin = Module.new do
-      def namespace_files
-        super
-        require_target = vendor_lib.sub(%r{^(.+?/)?lib/}, "") << "/lib"
-        relative_files = files.map {|f| Pathname.new(f).relative_path_from(Pathname.new(vendor_lib) / "lib").sub_ext("").to_s }
-        process_files(/require (['"])(#{Regexp.union(relative_files)})/, "require \\1#{require_target}/\\2")
-      end
-    end
-    lib.send(:extend, mixin)
+  desc "Vendor a specific version of connection_pool"
+  Automatiek::RakeTask.new("connection_pool") do |lib|
+    lib.download = { :github => "https://github.com/mperham/connection_pool" }
+    lib.namespace = "ConnectionPool"
+    lib.prefix = "Bundler"
+    lib.vendor_lib = "lib/bundler/vendor/connection_pool"
   end
 end
 

bundler/lib/bundler/fetcher.rb

@@ -242,7 +242,7 @@ def connection
           Bundler.settings[:ssl_client_cert]
         raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
 
-        con = PersistentHTTP.new "bundler", :ENV
+        con = PersistentHTTP.new :name => "bundler", :proxy => :ENV
         if gem_proxy = Bundler.rubygems.configuration[:http_proxy]
           con.proxy = URI.parse(gem_proxy) if gem_proxy != :no_proxy
         end

bundler/lib/bundler/vendor/connection_pool/lib/connection_pool.rb

@@ -0,0 +1,161 @@
+require_relative 'connection_pool/version'
+require_relative 'connection_pool/timed_stack'
+
+
+# Generic connection pool class for e.g. sharing a limited number of network connections
+# among many threads.  Note: Connections are lazily created.
+#
+# Example usage with block (faster):
+#
+#    @pool = Bundler::ConnectionPool.new { Redis.new }
+#
+#    @pool.with do |redis|
+#      redis.lpop('my-list') if redis.llen('my-list') > 0
+#    end
+#
+# Using optional timeout override (for that single invocation)
+#
+#    @pool.with(timeout: 2.0) do |redis|
+#      redis.lpop('my-list') if redis.llen('my-list') > 0
+#    end
+#
+# Example usage replacing an existing connection (slower):
+#
+#    $redis = Bundler::ConnectionPool.wrap { Redis.new }
+#
+#    def do_work
+#      $redis.lpop('my-list') if $redis.llen('my-list') > 0
+#    end
+#
+# Accepts the following options:
+# - :size - number of connections to pool, defaults to 5
+# - :timeout - amount of time to wait for a connection if none currently available, defaults to 5 seconds
+#
+class Bundler::ConnectionPool
+  DEFAULTS = {size: 5, timeout: 5}
+
+  class Error < RuntimeError
+  end
+
+  def self.wrap(options, &block)
+    Wrapper.new(options, &block)
+  end
+
+  def initialize(options = {}, &block)
+    raise ArgumentError, 'Connection pool requires a block' unless block
+
+    options = DEFAULTS.merge(options)
+
+    @size = options.fetch(:size)
+    @timeout = options.fetch(:timeout)
+
+    @available = TimedStack.new(@size, &block)
+    @key = :"current-#{@available.object_id}"
+    @key_count = :"current-#{@available.object_id}-count"
+  end
+
+if Thread.respond_to?(:handle_interrupt)
+
+  # MRI
+  def with(options = {})
+    Thread.handle_interrupt(Exception => :never) do
+      conn = checkout(options)
+      begin
+        Thread.handle_interrupt(Exception => :immediate) do
+          yield conn
+        end
+      ensure
+        checkin
+      end
+    end
+  end
+
+else
+
+  # jruby 1.7.x
+  def with(options = {})
+    conn = checkout(options)
+    begin
+      yield conn
+    ensure
+      checkin
+    end
+  end
+
+end
+
+  def checkout(options = {})
+    if ::Thread.current[@key]
+      ::Thread.current[@key_count]+= 1
+      ::Thread.current[@key]
+    else
+      ::Thread.current[@key_count]= 1
+      ::Thread.current[@key]= @available.pop(options[:timeout] || @timeout)
+    end
+  end
+
+  def checkin
+    if ::Thread.current[@key]
+      if ::Thread.current[@key_count] == 1
+        @available.push(::Thread.current[@key])
+        ::Thread.current[@key]= nil
+      else
+        ::Thread.current[@key_count]-= 1
+      end
+    else
+      raise Bundler::ConnectionPool::Error, 'no connections are checked out'
+    end
+
+    nil
+  end
+
+  def shutdown(&block)
+    @available.shutdown(&block)
+  end
+
+  # Size of this connection pool
+  def size
+    @size
+  end
+
+  # Number of pool entries available for checkout at this instant.
+  def available
+    @available.length
+  end
+
+  private
+
+  class Wrapper < ::BasicObject
+    METHODS = [:with, :pool_shutdown]
+
+    def initialize(options = {}, &block)
+      @pool = options.fetch(:pool) { ::Bundler::ConnectionPool.new(options, &block) }
+    end
+
+    def with(&block)
+      @pool.with(&block)
+    end
+
+    def pool_shutdown(&block)
+      @pool.shutdown(&block)
+    end
+
+    def pool_size
+      @pool.size
+    end
+
+    def pool_available
+      @pool.available
+    end
+
+    def respond_to?(id, *args)
+      METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
+    end
+
+    def method_missing(name, *args, &block)
+      with do |connection|
+        connection.send(name, *args, &block)
+      end
+    end
+  end
+end

bundler/lib/bundler/vendor/connection_pool/lib/connection_pool/monotonic_time.rb

@@ -0,0 +1,66 @@
+# Global monotonic clock from Concurrent Ruby 1.0.
+# Copyright (c) Jerry D'Antonio -- released under the MIT license.
+# Slightly modified; used with permission.
+# https://github.com/ruby-concurrency/concurrent-ruby
+
+require 'thread'
+
+class Bundler::ConnectionPool
+
+  class_definition = Class.new do
+
+    if defined?(Process::CLOCK_MONOTONIC)
+
+      # @!visibility private
+      def get_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+    elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+      # @!visibility private
+      def get_time
+        java.lang.System.nanoTime() / 1_000_000_000.0
+      end
+
+    else
+
+      # @!visibility private
+      def initialize
+        @mutex = Mutex.new
+        @last_time = Time.now.to_f
+      end
+
+      # @!visibility private
+      def get_time
+        @mutex.synchronize do
+          now = Time.now.to_f
+          if @last_time < now
+            @last_time = now
+          else # clock has moved back in time
+            @last_time += 0.000_001
+          end
+        end
+      end
+    end
+  end
+
+  ##
+  # Clock that cannot be set and represents monotonic time since
+  # some unspecified starting point.
+  #
+  # @!visibility private
+  GLOBAL_MONOTONIC_CLOCK = class_definition.new
+  private_constant :GLOBAL_MONOTONIC_CLOCK
+
+  class << self
+    ##
+    # Returns the current time a tracked by the application monotonic clock.
+    #
+    # @return [Float] The current monotonic time when `since` not given else
+    #   the elapsed monotonic time between `since` and the current time
+    def monotonic_time
+      GLOBAL_MONOTONIC_CLOCK.get_time
+    end
+  end
+end