Use vendored net-http in Bundler

Author: deivid-rodriguez

Manifest.txt

@@ -333,6 +333,7 @@ bundler/lib/bundler/vendor/uri/lib/uri/version.rb
 bundler/lib/bundler/vendor/uri/lib/uri/ws.rb
 bundler/lib/bundler/vendor/uri/lib/uri/wss.rb
 bundler/lib/bundler/vendored_fileutils.rb
+bundler/lib/bundler/vendored_net_http.rb
 bundler/lib/bundler/vendored_persistent.rb
 bundler/lib/bundler/vendored_pub_grub.rb
 bundler/lib/bundler/vendored_thor.rb

Rakefile

@@ -147,25 +147,6 @@ if File.exist?("tool/automatiek.rake")
     lib.license_path = "COPYING"
   end
 
-  desc "Vendor a specific version of net-http"
-  Automatiek::RakeTask.new("net-http") do |lib|
-    lib.version = "v0.4.0"
-    lib.download = { github: "https://github.com/ruby/net-http" }
-    lib.namespace = "Net"
-    lib.prefix = "Gem"
-    lib.vendor_lib = "lib/rubygems/net-http"
-    lib.license_path = "LICENSE.txt"
-
-    lib.dependency("net-protocol") do |sublib|
-      sublib.version = "v0.2.2"
-      sublib.download = { github: "https://github.com/ruby/net-protocol" }
-      sublib.namespace = "Net"
-      sublib.prefix = "Gem"
-      sublib.vendor_lib = "lib/rubygems/net-protocol"
-      sublib.license_path = "License.txt"
-    end
-  end
-
   desc "Vendor a specific version of pub_grub to bundler"
   Automatiek::RakeTask.new("pub_grub") do |lib|
     lib.version = "main"
@@ -208,12 +189,13 @@ if File.exist?("tool/automatiek.rake")
 
   # We currently include the following changes over the official version:
   # * Avoid requiring the optional `net-http-pipeline` dependency, so that its version can be selected by end users.
+  # * Require vendored net/http version RubyGems if available, otherwise the stdlib version.
   desc "Vendor a specific version of net-http-persistent to bundler"
   Automatiek::RakeTask.new("net-http-persistent") do |lib|
     lib.version = "v4.0.2"
     lib.download = { github: "https://github.com/drbrain/net-http-persistent" }
     lib.namespace = "Net::HTTP::Persistent"
-    lib.prefix = "Bundler::Persistent"
+    lib.prefix = "Gem"
     lib.vendor_lib = "bundler/lib/bundler/vendor/net-http-persistent"
     lib.license_path = "README.rdoc"
 
@@ -234,6 +216,24 @@ if File.exist?("tool/automatiek.rake")
       sublib.vendor_lib = "bundler/lib/bundler/vendor/uri"
       sublib.license_path = "LICENSE.txt"
     end
+
+    lib.dependency("net-http") do |sublib|
+      sublib.version = "v0.4.0"
+      sublib.download = { github: "https://github.com/ruby/net-http" }
+      sublib.namespace = "Net"
+      sublib.prefix = "Gem"
+      sublib.vendor_lib = "lib/rubygems/net-http"
+      sublib.license_path = "LICENSE.txt"
+
+      sublib.dependency("net-protocol") do |subsublib|
+        subsublib.version = "v0.2.2"
+        subsublib.download = { github: "https://github.com/ruby/net-protocol" }
+        subsublib.namespace = "Net"
+        subsublib.prefix = "Gem"
+        subsublib.vendor_lib = "lib/rubygems/net-protocol"
+        subsublib.license_path = "License.txt"
+      end
+    end
   end
 end
 

bundler/lib/bundler/compact_index_client/updater.rb

@@ -33,11 +33,11 @@ def append(remote_path, local_path, etag_path)
           # Subtract a byte to ensure the range won't be empty.
           # Avoids 416 (Range Not Satisfiable) responses.
           response = @fetcher.call(remote_path, request_headers(etag, file.size - 1))
-          break true if response.is_a?(Net::HTTPNotModified)
+          break true if response.is_a?(Gem::Net::HTTPNotModified)
 
           file.digests = parse_digests(response)
           # server may ignore Range and return the full response
-          if response.is_a?(Net::HTTPPartialContent)
+          if response.is_a?(Gem::Net::HTTPPartialContent)
             break false unless file.append(response.body.byteslice(1..-1))
           else
             file.write(response.body)
@@ -51,7 +51,7 @@ def append(remote_path, local_path, etag_path)
       def replace(remote_path, local_path, etag_path)
         etag = etag_path.read.tap(&:chomp!) if etag_path.file?
         response = @fetcher.call(remote_path, request_headers(etag))
-        return true if response.is_a?(Net::HTTPNotModified)
+        return true if response.is_a?(Gem::Net::HTTPNotModified)
         CacheFile.write(local_path, response.body, parse_digests(response))
         CacheFile.write(etag_path, etag(response))
       end

bundler/lib/bundler/fetcher.rb

@@ -82,7 +82,7 @@ def initialize(remote_uri)
     FAIL_ERRORS = begin
       fail_errors = [AuthenticationRequiredError, BadAuthenticationError, AuthenticationForbiddenError, FallbackError, SecurityError]
       fail_errors << Gem::Requirement::BadRequirementError
-      fail_errors.concat(NET_ERRORS.map {|e| Net.const_get(e) })
+      fail_errors.concat(NET_ERRORS.map {|e| Gem::Net.const_get(e) })
     end.freeze
 
     class << self
@@ -252,7 +252,7 @@ def connection
                     Bundler.settings[:ssl_client_cert]
         raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
 
-        con = PersistentHTTP.new name: "bundler", proxy: :ENV
+        con = Gem::Net::HTTP::Persistent.new name: "bundler", proxy: :ENV
         if gem_proxy = Gem.configuration[:http_proxy]
           con.proxy = Bundler::URI.parse(gem_proxy) if gem_proxy != :no_proxy
         end
@@ -289,8 +289,8 @@ def gemspec_cached_path(spec_file_name)
     HTTP_ERRORS = [
       Timeout::Error, EOFError, SocketError, Errno::ENETDOWN, Errno::ENETUNREACH,
       Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
-      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
-      PersistentHTTP::Error, Zlib::BufError, Errno::EHOSTUNREACH
+      Gem::Net::HTTPBadResponse, Gem::Net::HTTPHeaderSyntaxError, Gem::Net::ProtocolError,
+      Gem::Net::HTTP::Persistent::Error, Zlib::BufError, Errno::EHOSTUNREACH
     ].freeze
 
     def bundler_cert_store

bundler/lib/bundler/fetcher/compact_index.rb

@@ -121,7 +121,7 @@ def call(path, headers)
         rescue NetworkDownError => e
           raise unless Bundler.feature_flag.allow_offline_install? && headers["If-None-Match"]
           ui.warn "Using the cached data for the new index because of a network error: #{e}"
-          Net::HTTPNotModified.new(nil, nil, nil)
+          Gem::Net::HTTPNotModified.new(nil, nil, nil)
         end
       end
     end

bundler/lib/bundler/fetcher/downloader.rb

@@ -20,33 +20,35 @@ def fetch(uri, headers = {}, counter = 0)
         Bundler.ui.debug("HTTP #{response.code} #{response.message} #{filtered_uri}")
 
         case response
-        when Net::HTTPSuccess, Net::HTTPNotModified
+        when Gem::Net::HTTPSuccess, Gem::Net::HTTPNotModified
           response
-        when Net::HTTPRedirection
+        when Gem::Net::HTTPRedirection
           new_uri = Bundler::URI.parse(response["location"])
           if new_uri.host == uri.host
             new_uri.user = uri.user
             new_uri.password = uri.password
           end
           fetch(new_uri, headers, counter + 1)
-        when Net::HTTPRequestedRangeNotSatisfiable
+        when Gem::Net::HTTPRequestedRangeNotSatisfiable
           new_headers = headers.dup
           new_headers.delete("Range")
           new_headers["Accept-Encoding"] = "gzip"
           fetch(uri, new_headers)
-        when Net::HTTPRequestEntityTooLarge
+        when Gem::Net::HTTPRequestEntityTooLarge
           raise FallbackError, response.body
-        when Net::HTTPTooManyRequests
+        when Gem::Net::HTTPTooManyRequests
           raise TooManyRequestsError, response.body
-        when Net::HTTPUnauthorized
+        when Gem::Net::HTTPUnauthorized
           raise BadAuthenticationError, uri.host if uri.userinfo
           raise AuthenticationRequiredError, uri.host
-        when Net::HTTPForbidden
+        when Gem::Net::HTTPForbidden
           raise AuthenticationForbiddenError, uri.host
-        when Net::HTTPNotFound
-          raise FallbackError, "Net::HTTPNotFound: #{filtered_uri}"
+        when Gem::Net::HTTPNotFound
+          raise FallbackError, "Gem::Net::HTTPNotFound: #{filtered_uri}"
         else
-          raise HTTPError, "#{response.class}#{": #{response.body}" unless response.body.empty?}"
+          message = "Gem::#{response.class.name.gsub(/\AGem::/, "")}"
+          message += ": #{response.body}" unless response.body.empty?
+          raise HTTPError, message
         end
       end
 
@@ -56,7 +58,7 @@ def request(uri, headers)
         filtered_uri = URICredentialsFilter.credential_filtered_uri(uri)
 
         Bundler.ui.debug "HTTP GET #{filtered_uri}"
-        req = Net::HTTP::Get.new uri.request_uri, headers
+        req = Gem::Net::HTTP::Get.new uri.request_uri, headers
         if uri.user
           user = CGI.unescape(uri.user)
           password = uri.password ? CGI.unescape(uri.password) : nil