Vendor timeout in RubyGems too

deivid-rodriguez · deivid-rodriguez · commit e2e7440ede77 · 2023-12-12T19:12:46.000+01:00
diff --git a/.rubocop.yml b/.rubocop.yml
@@ -9,6 +9,7 @@ AllCops:
     - bundler/tmp/**/*
     - lib/rubygems/resolver/molinillo/**/*
     - lib/rubygems/tsort/**/*
+    - lib/rubygems/timeout/**/*
     - lib/rubygems/optparse/**/*
     - lib/rubygems/net-protocol/**/*
     - lib/rubygems/net-http/**/*
diff --git a/Manifest.txt b/Manifest.txt
@@ -559,6 +559,8 @@ lib/rubygems/ssl_certs/rubygems.org/GlobalSignRootCA.pem
 lib/rubygems/ssl_certs/rubygems.org/GlobalSignRootCA_R3.pem
 lib/rubygems/stub_specification.rb
 lib/rubygems/text.rb
+lib/rubygems/timeout.rb
+lib/rubygems/timeout/lib/timeout.rb
 lib/rubygems/tsort.rb
 lib/rubygems/tsort/.document
 lib/rubygems/tsort/LICENSE.txt
diff --git a/Rakefile b/Rakefile
@@ -232,6 +232,24 @@ if File.exist?("tool/automatiek.rake")
         subsublib.prefix = "Gem"
         subsublib.vendor_lib = "lib/rubygems/net-protocol"
         subsublib.license_path = "License.txt"
+
+        subsublib.dependency("timeout") do |ssslib|
+          ssslib.version = "v0.4.1"
+          ssslib.download = { github: "https://github.com/ruby/timeout" }
+          ssslib.namespace = "Timeout"
+          ssslib.prefix = "Gem"
+          ssslib.vendor_lib = "lib/rubygems/timeout"
+          ssslib.license_path = "License.txt"
+        end
+      end
+
+      sublib.dependency("timeout") do |subsublib|
+        subsublib.version = "v0.4.1"
+        subsublib.download = { github: "https://github.com/ruby/timeout" }
+        subsublib.namespace = "Timeout"
+        subsublib.prefix = "Gem"
+        subsublib.vendor_lib = "lib/rubygems/timeout"
+        subsublib.license_path = "License.txt"
       end
     end
   end
diff --git a/lib/rubygems/command_manager.rb b/lib/rubygems/command_manager.rb
@@ -106,7 +106,7 @@ def self.reset
   # Register all the subcommands supported by the gem command.
 
   def initialize
-    require "timeout"
+    require_relative "timeout"
     @commands = {}
 
     BUILTIN_COMMANDS.each do |name|
@@ -149,7 +149,7 @@ def command_names
 
   def run(args, build_args=nil)
     process_args(args, build_args)
-  rescue StandardError, Timeout::Error => ex
+  rescue StandardError, Gem::Timeout::Error => ex
     if ex.respond_to?(:detailed_message)
       msg = ex.detailed_message(highlight: false).sub(/\A(.*?)(?: \(.+?\))/) { $1 }
     else
diff --git a/lib/rubygems/gemcutter_utilities/webauthn_poller.rb b/lib/rubygems/gemcutter_utilities/webauthn_poller.rb
@@ -37,13 +37,13 @@ def self.poll_thread(options, host, webauthn_url, credentials)
         thread.abort_on_exception = true
         thread.report_on_exception = false
         thread[:otp] = new(options, host).poll_for_otp(webauthn_url, credentials)
-      rescue Gem::WebauthnVerificationError, Timeout::Error => e
+      rescue Gem::WebauthnVerificationError, Gem::Timeout::Error => e
         thread[:error] = e
       end
     end
 
     def poll_for_otp(webauthn_url, credentials)
-      Timeout.timeout(TIMEOUT_IN_SECONDS) do
+      Gem::Timeout.timeout(TIMEOUT_IN_SECONDS) do
         loop do
           response = webauthn_verification_poll_response(webauthn_url, credentials)
           raise Gem::WebauthnVerificationError, response.message unless response.is_a?(Gem::Net::HTTPSuccess)
diff --git a/lib/rubygems/net-http/lib/net/http.rb b/lib/rubygems/net-http/lib/net/http.rb
@@ -1308,7 +1308,7 @@ def ipaddr=(addr)
     # Sets the maximum number of times to retry an idempotent request in case of
     # \Gem::Net::ReadTimeout, IOError, EOFError, Errno::ECONNRESET,
     # Errno::ECONNABORTED, Errno::EPIPE, OpenSSL::SSL::SSLError,
-    # Timeout::Error.
+    # Gem::Timeout::Error.
     # The initial value is 1.
     #
     # Argument +retries+ must be a non-negative numeric value:
@@ -1598,7 +1598,7 @@ def connect
       end
 
       debug "opening connection to #{conn_addr}:#{conn_port}..."
-      s = Timeout.timeout(@open_timeout, Gem::Net::OpenTimeout) {
+      s = Gem::Timeout.timeout(@open_timeout, Gem::Net::OpenTimeout) {
         begin
           TCPSocket.open(conn_addr, conn_port, @local_host, @local_port)
         rescue => e
@@ -2358,7 +2358,7 @@ def transport_request(req)
              Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE, Errno::ETIMEDOUT,
              # avoid a dependency on OpenSSL
              defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : IOError,
-             Timeout::Error => exception
+             Gem::Timeout::Error => exception
         if count < max_retries && IDEMPOTENT_METHODS_.include?(req.method)
           count += 1
           @socket.close if @socket
diff --git a/lib/rubygems/net-http/lib/net/http/responses.rb b/lib/rubygems/net-http/lib/net/http/responses.rb
@@ -589,7 +589,7 @@ class HTTPProxyAuthenticationRequired < HTTPClientError
     HAS_BODY = true
   end
 
-  # Response class for <tt>Request Timeout</tt> responses (status code 408).
+  # Response class for <tt>Request Gem::Timeout</tt> responses (status code 408).
   #
   # The server timed out waiting for the request.
   #
@@ -980,7 +980,7 @@ class HTTPServiceUnavailable < HTTPServerError
     HAS_BODY = true
   end
 
-  # Response class for <tt>Gateway Timeout</tt> responses (status code 504).
+  # Response class for <tt>Gateway Gem::Timeout</tt> responses (status code 504).
   #
   # The server was acting as a gateway or proxy
   # and did not receive a timely response from the upstream server.
diff --git a/lib/rubygems/net-protocol/lib/net/protocol.rb b/lib/rubygems/net-protocol/lib/net/protocol.rb
@@ -20,7 +20,7 @@
 #
 
 require 'socket'
-require 'timeout'
+require_relative '../../../timeout/lib/timeout'
 require 'io/wait'
 
 module Gem::Net # :nodoc:
@@ -68,16 +68,16 @@ class ProtoRetriableError    < ProtocolError; end
   ProtocRetryError = ProtoRetriableError
 
   ##
-  # OpenTimeout, a subclass of Timeout::Error, is raised if a connection cannot
+  # OpenTimeout, a subclass of Gem::Timeout::Error, is raised if a connection cannot
   # be created within the open_timeout.
 
-  class OpenTimeout            < Timeout::Error; end
+  class OpenTimeout            < Gem::Timeout::Error; end
 
   ##
-  # ReadTimeout, a subclass of Timeout::Error, is raised if a chunk of the
+  # ReadTimeout, a subclass of Gem::Timeout::Error, is raised if a chunk of the
   # response cannot be read within the read_timeout.
 
-  class ReadTimeout < Timeout::Error
+  class ReadTimeout < Gem::Timeout::Error
     def initialize(io = nil)
       @io = io
     end
@@ -93,10 +93,10 @@ def message
   end
 
   ##
-  # WriteTimeout, a subclass of Timeout::Error, is raised if a chunk of the
+  # WriteTimeout, a subclass of Gem::Timeout::Error, is raised if a chunk of the
   # response cannot be written within the write_timeout.  Not raised on Windows.
 
-  class WriteTimeout < Timeout::Error
+  class WriteTimeout < Gem::Timeout::Error
     def initialize(io = nil)
       @io = io
     end
diff --git a/lib/rubygems/remote_fetcher.rb b/lib/rubygems/remote_fetcher.rb
@@ -261,7 +261,7 @@ def fetch_path(uri, mtime = nil, head = false)
     end
 
     data
-  rescue Timeout::Error, IOError, SocketError, SystemCallError,
+  rescue Gem::Timeout::Error, IOError, SocketError, SystemCallError,
          *(OpenSSL::SSL::SSLError if Gem::HAVE_OPENSSL) => e
     raise FetchError.new("#{e.class}: #{e}", uri)
   end
diff --git a/lib/rubygems/request.rb b/lib/rubygems/request.rb
@@ -244,7 +244,7 @@ def perform_request(request) # :nodoc:
     # HACK: work around EOFError bug in Gem::Net::HTTP
     # NOTE Errno::ECONNABORTED raised a lot on Windows, and make impossible
     # to install gems.
-    rescue EOFError, Timeout::Error,
+    rescue EOFError, Gem::Timeout::Error,
            Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE
 
       requests = @requests[connection.object_id]
diff --git a/lib/rubygems/timeout.rb b/lib/rubygems/timeout.rb
@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "timeout/lib/timeout"
diff --git a/lib/rubygems/timeout/lib/timeout.rb b/lib/rubygems/timeout/lib/timeout.rb
@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+# Timeout long-running blocks
+#
+# == Synopsis
+#
+#   require 'rubygems/timeout/lib/timeout'
+#   status = Gem::Timeout::timeout(5) {
+#     # Something that should be interrupted if it takes more than 5 seconds...
+#   }
+#
+# == Description
+#
+# Gem::Timeout provides a way to auto-terminate a potentially long-running
+# operation if it hasn't finished in a fixed amount of time.
+#
+# Previous versions didn't use a module for namespacing, however
+# #timeout is provided for backwards compatibility.  You
+# should prefer Gem::Timeout.timeout instead.
+#
+# == Copyright
+#
+# Copyright:: (C) 2000  Network Applied Communication Laboratory, Inc.
+# Copyright:: (C) 2000  Information-technology Promotion Agency, Japan
+
+module Gem::Timeout
+  VERSION = "0.4.1"
+
+  # Internal error raised to when a timeout is triggered.
+  class ExitException < Exception
+    def exception(*)
+      self
+    end
+  end
+
+  # Raised by Gem::Timeout.timeout when the block times out.
+  class Error < RuntimeError
+    def self.handle_timeout(message)
+      exc = ExitException.new(message)
+
+      begin
+        yield exc
+      rescue ExitException => e
+        raise new(message) if exc.equal?(e)
+        raise
+      end
+    end
+  end
+
+  # :stopdoc:
+  CONDVAR = ConditionVariable.new
+  QUEUE = Queue.new
+  QUEUE_MUTEX = Mutex.new
+  TIMEOUT_THREAD_MUTEX = Mutex.new
+  @timeout_thread = nil
+  private_constant :CONDVAR, :QUEUE, :QUEUE_MUTEX, :TIMEOUT_THREAD_MUTEX
+
+  class Request
+    attr_reader :deadline
+
+    def initialize(thread, timeout, exception_class, message)
+      @thread = thread
+      @deadline = GET_TIME.call(Process::CLOCK_MONOTONIC) + timeout
+      @exception_class = exception_class
+      @message = message
+
+      @mutex = Mutex.new
+      @done = false # protected by @mutex
+    end
+
+    def done?
+      @mutex.synchronize do
+        @done
+      end
+    end
+
+    def expired?(now)
+      now >= @deadline
+    end
+
+    def interrupt
+      @mutex.synchronize do
+        unless @done
+          @thread.raise @exception_class, @message
+          @done = true
+        end
+      end
+    end
+
+    def finished
+      @mutex.synchronize do
+        @done = true
+      end
+    end
+  end
+  private_constant :Request
+
+  def self.create_timeout_thread
+    watcher = Thread.new do
+      requests = []
+      while true
+        until QUEUE.empty? and !requests.empty? # wait to have at least one request
+          req = QUEUE.pop
+          requests << req unless req.done?
+        end
+        closest_deadline = requests.min_by(&:deadline).deadline
+
+        now = 0.0
+        QUEUE_MUTEX.synchronize do
+          while (now = GET_TIME.call(Process::CLOCK_MONOTONIC)) < closest_deadline and QUEUE.empty?
+            CONDVAR.wait(QUEUE_MUTEX, closest_deadline - now)
+          end
+        end
+
+        requests.each do |req|
+          req.interrupt if req.expired?(now)
+        end
+        requests.reject!(&:done?)
+      end
+    end
+    ThreadGroup::Default.add(watcher) unless watcher.group.enclosed?
+    watcher.name = "Gem::Timeout stdlib thread"
+    watcher.thread_variable_set(:"\0__detached_thread__", true)
+    watcher
+  end
+  private_class_method :create_timeout_thread
+
+  def self.ensure_timeout_thread_created
+    unless @timeout_thread and @timeout_thread.alive?
+      TIMEOUT_THREAD_MUTEX.synchronize do
+        unless @timeout_thread and @timeout_thread.alive?
+          @timeout_thread = create_timeout_thread
+        end
+      end
+    end
+  end
+
+  # We keep a private reference so that time mocking libraries won't break
+  # Gem::Timeout.
+  GET_TIME = Process.method(:clock_gettime)
+  private_constant :GET_TIME
+
+  # :startdoc:
+
+  # Perform an operation in a block, raising an error if it takes longer than
+  # +sec+ seconds to complete.
+  #
+  # +sec+:: Number of seconds to wait for the block to terminate. Any number
+  #         may be used, including Floats to specify fractional seconds. A
+  #         value of 0 or +nil+ will execute the block without any timeout.
+  # +klass+:: Exception Class to raise if the block fails to terminate
+  #           in +sec+ seconds.  Omitting will use the default, Gem::Timeout::Error
+  # +message+:: Error message to raise with Exception Class.
+  #             Omitting will use the default, "execution expired"
+  #
+  # Returns the result of the block *if* the block completed before
+  # +sec+ seconds, otherwise throws an exception, based on the value of +klass+.
+  #
+  # The exception thrown to terminate the given block cannot be rescued inside
+  # the block unless +klass+ is given explicitly. However, the block can use
+  # ensure to prevent the handling of the exception.  For that reason, this
+  # method cannot be relied on to enforce timeouts for untrusted blocks.
+  #
+  # If a scheduler is defined, it will be used to handle the timeout by invoking
+  # Scheduler#timeout_after.
+  #
+  # Note that this is both a method of module Gem::Timeout, so you can <tt>include
+  # Gem::Timeout</tt> into your classes so they have a #timeout method, as well as
+  # a module method, so you can call it directly as Gem::Timeout.timeout().
+  def timeout(sec, klass = nil, message = nil, &block)   #:yield: +sec+
+    return yield(sec) if sec == nil or sec.zero?
+
+    message ||= "execution expired"
+
+    if Fiber.respond_to?(:current_scheduler) && (scheduler = Fiber.current_scheduler)&.respond_to?(:timeout_after)
+      return scheduler.timeout_after(sec, klass || Error, message, &block)
+    end
+
+    Gem::Timeout.ensure_timeout_thread_created
+    perform = Proc.new do |exc|
+      request = Request.new(Thread.current, sec, exc, message)
+      QUEUE_MUTEX.synchronize do
+        QUEUE << request
+        CONDVAR.signal
+      end
+      begin
+        return yield(sec)
+      ensure
+        request.finished
+      end
+    end
+
+    if klass
+      perform.call(klass)
+    else
+      Error.handle_timeout(message, &perform)
+    end
+  end
+  module_function :timeout
+end
diff --git a/test/rubygems/test_gem_remote_fetcher.rb b/test/rubygems/test_gem_remote_fetcher.rb
diff --git a/test/rubygems/test_gem_request_connection_pools.rb b/test/rubygems/test_gem_request_connection_pools.rb
diff --git a/test/rubygems/test_gem_silent_ui.rb b/test/rubygems/test_gem_silent_ui.rb
diff --git a/test/rubygems/test_gem_stream_ui.rb b/test/rubygems/test_gem_stream_ui.rb
diff --git a/test/rubygems/test_webauthn_poller.rb b/test/rubygems/test_webauthn_poller.rb

Original file line number	Diff line number	Diff line change
`@@ -589,7 +589,7 @@ class HTTPProxyAuthenticationRequired < HTTPClientError`
`589`	`589`	`HAS_BODY = true`
`590`	`590`	`end`
`591`	`591`
`592`		`- # Response class for <tt>Request Timeout</tt> responses (status code 408).`
	`592`	`+ # Response class for <tt>Request Gem::Timeout</tt> responses (status code 408).`
`593`	`593`	`#`
`594`	`594`	`# The server timed out waiting for the request.`
`595`	`595`	`#`
`@@ -980,7 +980,7 @@ class HTTPServiceUnavailable < HTTPServerError`
`980`	`980`	`HAS_BODY = true`
`981`	`981`	`end`
`982`	`982`
`983`		`- # Response class for <tt>Gateway Timeout</tt> responses (status code 504).`
	`983`	`+ # Response class for <tt>Gateway Gem::Timeout</tt> responses (status code 504).`
`984`	`984`	`#`
`985`	`985`	`# The server was acting as a gateway or proxy`
`986`	`986`	`# and did not receive a timely response from the upstream server.`