curb 1.2.2 → 1.3.2

data/tests/tc_fiber_scheduler.rb

@@ -12,6 +12,51 @@ end
 # by running multiple requests concurrently in a single thread using the Async gem.
 class TestCurbFiberScheduler < Test::Unit::TestCase
   include BugTestServerSetupTeardown
+  include TestServerMethods
+
+  class RecordingScheduler
+    attr_reader :io_wait_events
+
+    def initialize
+      @io_wait_events = []
+    end
+
+    def fiber(&block)
+      Fiber.new(blocking: false, &block)
+    end
+
+    def io_wait(io, events, timeout = nil)
+      @io_wait_events << events
+      raise TypeError, "expected Integer events, got #{events.class}" unless events.is_a?(Integer)
+
+      readers = (events & IO::READABLE) != 0 ? [io] : nil
+      writers = (events & IO::WRITABLE) != 0 ? [io] : nil
+      readable, writable = IO.select(readers, writers, nil, timeout)
+
+      ready = 0
+      ready |= IO::READABLE if readable && !readable.empty?
+      ready |= IO::WRITABLE if writable && !writable.empty?
+      ready.zero? ? false : ready
+    end
+
+    def kernel_sleep(duration = nil)
+      sleep(duration || 0)
+    end
+
+    def block(_blocker, timeout = nil)
+      sleep(timeout || 0)
+      false
+    end
+
+    def unblock(*)
+    end
+
+    def close
+    end
+
+    def fiber_interrupt(*)
+    end
+  end
 
   ITERS = 4
   MIN_S = 0.25
@@ -50,6 +95,8 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
         m.add(c)
       end
       m.perform
+    ensure
+      m.close if m
     end
 
     duration = Time.now - started
@@ -109,6 +156,8 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       m.perform do
         yielded += 1
       end
+    ensure
+      m.close if m
     end
 
     assert_operator yielded, :>=, 1, 'perform did not yield block while waiting under scheduler'
@@ -130,20 +179,49 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       c.on_complete { result = c.code }
       m.add(c)
       m.perform
+    ensure
+      m.close if m
     end
 
     assert_equal 200, result
   end
 
+  def test_multi_single_request_socket_perform_passes_integer_events_to_io_wait
+    omit('Skipping custom scheduler test on Windows') if WINDOWS
+    omit('Fiber scheduler API unavailable on this Ruby') unless fiber_scheduler_supported?
+
+    url = "http://127.0.0.1:#{@port}/test"
+    scheduler = RecordingScheduler.new
+    result = nil
+
+    with_scheduler(scheduler) do
+      m = Curl::Multi.new
+      c = Curl::Easy.new(url)
+      c.on_complete { result = c.code }
+      m.add(c)
+      unless m.respond_to?(:_socket_perform, true)
+        omit('socket-action perform path is not available in this build')
+      end
+      m.send(:_socket_perform)
+    ensure
+      m.close if m
+    end
+
+    assert_equal 200, result
+    assert_operator scheduler.io_wait_events.length, :>=, 1
+    assert scheduler.io_wait_events.all? { |events| events.is_a?(Integer) }
+    assert scheduler.io_wait_events.any? { |events| (events & (IO::READABLE | IO::WRITABLE)) != 0 }
+  end
+
   def test_multi_reuse_after_scheduler_perform
     unless HAS_ASYNC
       warn 'Skipping fiber scheduler test (Async gem not available)'
       return
     end
-
+  
     url = "http://127.0.0.1:#{@port}/test"
     results = []
-
+  
     async_run do
       m = Curl::Multi.new
       # First round
@@ -151,15 +229,224 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       c1.on_complete { results << c1.code }
       m.add(c1)
       m.perform
-
+  
       # Second round on same multi
       c2 = Curl::Easy.new(url)
       c2.on_complete { results << c2.code }
       m.add(c2)
       m.perform
+    ensure
+      m.close if m
     end
+  
+    assert_equal [200, 200], results
+  end
 
+  def test_easy_perform_reuses_scheduler_multi_when_autoclose_is_enabled
+    if skip_no_async
+      return
+    end
+  
+    url = "http://127.0.0.1:#{@port}/test"
+    results = []
+    previous_autoclose = Curl::Multi.autoclose
+    Curl::Multi.autoclose = true
+  
+    async_run do
+      2.times do
+        easy = Curl::Easy.new(url)
+        easy.perform
+        results << easy.code
+      end
+    end
+  
     assert_equal [200, 200], results
+  ensure
+    Curl::Multi.autoclose = previous_autoclose if defined?(previous_autoclose)
+    cleanup_scheduler_state
+  end
+
+  def test_easy_perform_reraises_on_body_exception_under_scheduler
+    if skip_no_async
+      return
+    end
+  
+    url = "http://127.0.0.1:#{@port}/test"
+  
+    async_run do |top|
+      task = top.async do
+        c = Curl::Easy.new(url)
+        c.on_body { raise "body blew up" }
+        c.on_complete { sleep 0 }
+        c.perform
+      end
+  
+      error = assert_raise(RuntimeError) do
+        task.wait
+      end
+  
+      assert_equal "body blew up", error.message
+    end
+  end
+
+  def test_easy_perform_reraises_on_header_exception_under_scheduler
+    if skip_no_async
+      return
+    end
+
+    url = "http://127.0.0.1:#{@port}/test"
+
+    async_run do |top|
+      task = top.async do
+        c = Curl::Easy.new(url)
+        c.on_header { raise "header blew up" }
+        c.on_complete { sleep 0 }
+        c.perform
+      end
+
+      error = assert_raise(RuntimeError) do
+        task.wait
+      end
+
+      assert_equal "header blew up", error.message
+    end
+  end
+
+  def test_easy_perform_does_not_reraise_sibling_on_complete_exception_under_scheduler
+    if skip_no_async
+      return
+    end
+
+    with_ephemeral_http_server do |port, hits|
+      results = {}
+
+      async_run do |top|
+        successful = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/fast")
+          easy.perform
+          results[:successful] = easy.response_code
+        rescue => e
+          results[:successful] = e
+        end
+
+        failing = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/slow")
+          easy.on_complete { raise "boom" }
+          easy.perform
+          results[:failing] = :returned
+        rescue => e
+          results[:failing] = e
+        end
+
+        successful.wait
+        failing.wait
+      end
+
+      assert_equal 200, results[:successful], "successful scheduler peer should return normally"
+      assert_kind_of Curl::Err::AbortedByCallbackError, results[:failing]
+      assert_equal "boom", results[:failing].message
+      assert_equal 1, hits[:fast]
+      assert_equal 1, hits[:slow]
+    end
+  end
+
+  def test_easy_perform_does_not_reraise_fast_on_complete_exception_into_slow_successful_peer_under_scheduler
+    if skip_no_async
+      return
+    end
+
+    with_ephemeral_http_server do |port, hits|
+      results = {}
+
+      async_run do |top|
+        failing = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/fast")
+          easy.on_complete { raise "boom" }
+          easy.perform
+          results[:failing] = :returned
+        rescue => e
+          results[:failing] = e
+        end
+
+        successful = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/slow")
+          easy.perform
+          results[:successful] = easy.response_code
+        rescue => e
+          results[:successful] = e
+        end
+
+        failing.wait
+        successful.wait
+      end
+
+      assert_equal 200, results[:successful], "slow successful scheduler peer should not inherit a fast sibling callback error"
+      assert_kind_of Curl::Err::AbortedByCallbackError, results[:failing]
+      assert_equal "boom", results[:failing].message
+      assert_equal 1, hits[:fast]
+      assert_equal 1, hits[:slow]
+    end
+  end
+
+  def test_easy_perform_keeps_scheduler_timers_running_while_draining_deferred_on_complete_exception
+    if skip_no_async
+      return
+    end
+
+    with_ephemeral_http_server do |port, hits|
+      marks = {}
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      async_run do |top|
+        timer = top.async do
+          sleep 0.05
+          marks[:timer] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        end
+
+        failing = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/fast")
+          easy.on_complete { raise "boom" }
+          easy.perform
+          marks[:failing] = :returned
+        rescue => e
+          marks[:failing] = e
+        end
+
+        successful = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/slow")
+          easy.perform
+          marks[:slow_done] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        end
+
+        timer.wait
+        failing.wait
+        successful.wait
+      end
+
+      assert_kind_of Curl::Err::AbortedByCallbackError, marks[:failing]
+      assert_operator marks[:timer], :<, marks[:slow_done] - 0.02,
+                      "scheduler timer should fire before the slow sibling finishes draining"
+      assert_equal 1, hits[:fast]
+      assert_equal 1, hits[:slow]
+    end
+  end
+
+  def test_drain_scheduler_pending_does_not_drop_work_rejected_during_deferred_abort
+    state = Curl.scheduler_state
+    easy = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
+    waiter = {completed: false, done: false, error: nil}
+
+    state[:waiters][easy.object_id] = waiter
+    state[:pending] << easy
+    state[:multi].instance_variable_set(:@__curb_deferred_exception, RuntimeError.new("boom"))
+
+    Curl.drain_scheduler_pending(state)
+
+    assert(state[:pending].include?(easy) || waiter[:error],
+           "scheduler enqueue rejected during deferred abort should remain pending or fail its waiter instead of disappearing")
+    assert_equal 0, state[:multi].requests.length
+  ensure
+    cleanup_scheduler_state
   end
 
   private
@@ -168,6 +455,10 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       warn 'Skipping fiber scheduler tests on Windows'
       return true
     end
+    unless fiber_scheduler_supported?
+      warn 'Skipping fiber scheduler tests (Fiber scheduler API unavailable)'
+      return true
+    end
     unless HAS_ASYNC
       warn 'Skipping fiber scheduler test (Async gem not available)'
       return true
@@ -183,8 +474,52 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       Async(&block)
     end
   end
-end
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
-  warn 'Skipping fiber scheduler tests on Ruby < 3.1'
-  return
+
+  def fiber_scheduler_supported?
+    Fiber.respond_to?(:set_scheduler) && Fiber.respond_to?(:schedule)
+  end
+
+  def with_scheduler(scheduler)
+    previous_scheduler = Fiber.scheduler if Fiber.respond_to?(:scheduler)
+    Fiber.set_scheduler(scheduler)
+    fiber = Fiber.schedule { yield }
+    fiber.resume while fiber.alive?
+  ensure
+    Fiber.set_scheduler(previous_scheduler) if Fiber.respond_to?(:set_scheduler)
+  end
+
+  def cleanup_scheduler_state
+    state = Thread.current.thread_variable_get(:curb_scheduler_state)
+    state[:multi].close if state && state[:multi]
+    Thread.current.thread_variable_set(:curb_scheduler_state, nil)
+  end
+
+  def with_ephemeral_http_server
+    port_socket = TCPServer.new('127.0.0.1', 0)
+    port = port_socket.addr[1]
+    port_socket.close
+
+    hits = Hash.new(0)
+    server = WEBrick::HTTPServer.new(:Port => port, :Logger => WEBRICK_TEST_LOG, :AccessLog => [])
+    server.mount_proc('/fast') do |_req, res|
+      hits[:fast] += 1
+      res['Content-Type'] = 'text/plain'
+      res.body = 'fast'
+    end
+    server.mount_proc('/slow') do |_req, res|
+      hits[:slow] += 1
+      res['Content-Type'] = 'text/plain'
+      sleep 0.2
+      res.body = 'slow'
+    end
+
+    server_thread = Thread.new(server) { |srv| srv.start }
+    wait_for_server_ready(port, thread: server_thread)
+
+    yield port, hits
+  ensure
+    server.shutdown if defined?(server) && server
+    server_thread.join(server_startup_timeout) if defined?(server_thread) && server_thread
+    server_thread.kill if defined?(server_thread) && server_thread&.alive?
+  end
 end

data/tests/tc_gc_compact.rb

@@ -3,8 +3,9 @@
 require File.expand_path('helper', __dir__)
 
 class TestGcCompact < Test::Unit::TestCase
-  ITERATIONS = (ENV['CURB_GC_COMPACT_ITERATIONS'] || 5).to_i
+  ITERATIONS = (ENV['CURB_GC_COMPACT_ITERATIONS'] || 50).to_i
   EASY_PER_MULTI = 3
+  GC_CRASH_REGRESSION_ITERATIONS = (ENV['CURB_GC_CRASH_REGRESSION_ITERATIONS'] || [ITERATIONS, 10].min).to_i
 
   def setup
     omit('GC.compact unavailable on this Ruby') unless defined?(GC.compact)
@@ -12,38 +13,153 @@ class TestGcCompact < Test::Unit::TestCase
 
   def test_multi_perform_with_gc_compact
     ITERATIONS.times do
-      multi = Curl::Multi.new
-      add_easy_handles(multi)
-
-      compact
-      assert_nothing_raised { multi.perform }
-      compact
+      run_multi_perform_compact_iteration
+      collect_after_iteration
     end
   end
 
   def test_gc_compact_during_multi_cleanup
-    ITERATIONS.times do
-      multi = Curl::Multi.new
-      add_easy_handles(multi)
+    omit('GC cleanup isolation requires fork') if NO_FORK || WINDOWS
 
-      compact
-      multi = nil
-      compact
+    pid = fork do
+      begin
+        ITERATIONS.times do
+          run_multi_cleanup_compact_iteration
+          collect_after_iteration
+        end
+        exit! 0
+      rescue StandardError => e
+        warn("#{e.class}: #{e.message}")
+        warn(e.backtrace.join("\n")) if e.backtrace
+        exit! 1
+      end
     end
+
+    _child_pid, status = Process.wait2(pid)
+    assert_predicate status, :success?
   end
 
   def test_gc_compact_after_detach
+    run_multi_detach_compact_iteration
+    collect_after_iteration
+  end
+
+  def test_gc_compact_after_failed_implicit_multi_cleanup
+    GC_CRASH_REGRESSION_ITERATIONS.times do
+      run_failed_implicit_multi_cleanup_iteration(compact: true, cleanup_with_objectspace: false)
+      collect_after_iteration
+    end
+  end
+
+  def test_gc_cleanup_after_failed_implicit_multi_callback
+    omit('GC cleanup isolation requires fork') if NO_FORK || WINDOWS
+
+    assert_child_process_success do
+      GC_CRASH_REGRESSION_ITERATIONS.times do
+        run_failed_implicit_multi_cleanup_iteration(compact: true, cleanup_with_objectspace: true)
+      end
+    end
+  end
+
+  def test_gc_cleanup_after_invalid_multi_assignment_rejection
+    omit('GC cleanup isolation requires fork') if NO_FORK || WINDOWS
+
+    assert_child_process_success do
+      GC_CRASH_REGRESSION_ITERATIONS.times do
+        easy = Curl::Easy.new($TEST_URL)
+
+        begin
+          easy.multi = Object.new
+          raise 'expected TypeError from Curl::Easy#multi='
+        rescue TypeError => error
+          raise "unexpected error message: #{error.message}" unless /Curl::Multi/.match?(error.message)
+        end
+
+        easy = nil
+        full_gc(compact: true)
+      end
+    end
+  end
+
+  def test_gc_compact_easy
+    iteration = 0
+    responses = []
+    while iteration < ITERATIONS
+      res = Curl.get($TEST_URL) do |easy|
+        easy.timeout = 5
+        easy.on_complete { |_e| }
+        easy.on_failure { |_e, _code| }
+      end
+      iteration += 1
+      responses << res.body
+      compact
+    end
+  end
+
+  private
+
+  def run_multi_perform_compact_iteration
+    multi = Curl::Multi.new
+    handles = add_easy_handles(multi)
+
+    compact
+    multi.perform { compact }
+    compact
+  ensure
+    handles&.each do |easy|
+      begin
+        easy.close
+      rescue StandardError
+        nil
+      end
+    end
+    multi&.close
+  end
+
+  def run_multi_cleanup_compact_iteration
+    multi = Curl::Multi.new
+    add_easy_handles(multi)
+
+    compact
+    multi = nil
+    compact
+  end
+
+  def run_multi_detach_compact_iteration
     multi = Curl::Multi.new
     handles = add_easy_handles(multi)
 
     compact
-    assert_nothing_raised { multi.perform }
+    multi.perform { compact }
 
-    handles.each { |easy| multi.remove(easy) }
+    handles.each { |easy| multi.remove(easy); compact }
     compact
+  ensure
+    multi&.close
   end
 
-  private
+  def run_failed_implicit_multi_cleanup_iteration(compact:, cleanup_with_objectspace:)
+    easy = Curl::Easy.new($TEST_URL)
+    easy.on_complete { raise 'complete blew up' }
+
+    begin
+      easy.perform
+      raise 'expected callback abort'
+    rescue Curl::Err::AbortedByCallbackError => error
+      raise "unexpected callback message: #{error.message}" unless error.message == 'complete blew up'
+    end
+
+    raise 'expected implicit cleanup to clear easy.multi' unless easy.multi.nil?
+  ensure
+    easy = nil
+    if cleanup_with_objectspace
+      run_teardown_multi_cleanup
+      flush_deferred_multi_closes_all
+    else
+      flush_deferred_multi_closes_all
+    end
+    full_gc(compact: compact)
+  end
 
   def add_easy_handles(multi)
     Array.new(EASY_PER_MULTI) do
@@ -58,4 +174,50 @@ class TestGcCompact < Test::Unit::TestCase
   def compact
     GC.compact
   end
+
+  def full_gc(compact: false)
+    GC.start(full_mark: true, immediate_sweep: true)
+    GC.compact if compact && GC.respond_to?(:compact)
+    GC.start(full_mark: true, immediate_sweep: true)
+  end
+
+  def flush_deferred_multi_closes_all
+    return unless Curl::Easy.respond_to?(:flush_deferred_multi_closes)
+
+    Curl::Easy.flush_deferred_multi_closes(all_threads: true)
+  end
+
+  def run_teardown_multi_cleanup
+    ObjectSpace.each_object(Curl::Multi) do |multi|
+      begin
+        next if multi.instance_variable_defined?(:@deferred_close) && multi.instance_variable_get(:@deferred_close)
+
+        multi.instance_variable_set(:@requests, {})
+        multi._close
+      rescue StandardError
+        nil
+      end
+    end
+  end
+
+  def assert_child_process_success
+    pid = fork do
+      begin
+        yield
+        exit! 0
+      rescue Exception => e
+        warn("#{e.class}: #{e.message}")
+        warn(e.backtrace.join("\n")) if e.backtrace
+        exit! 1
+      end
+    end
+
+    _child_pid, status = Process.wait2(pid)
+    assert_predicate status, :success?
+  end
+
+  def collect_after_iteration
+    ObjectSpace.garbage_collect
+    ObjectSpace.garbage_collect
+  end
 end