curb 1.3.7 → 1.4.0

data/tests/tc_fiber_scheduler.rb

@@ -118,7 +118,7 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
 
     duration = Time.now - started
 
-    assert duration < THRESHOLD, "Requests did not run concurrently under fiber scheduler (#{duration}s) which exceeds the expected threshold of: #{THRESHOLD} serial time would be about: #{SERIAL_TIME_WOULD_BE_ABOUT}"
+    assert_ran_concurrently(duration)
     assert_equal ITERS, results.size
     assert_equal ITERS.times.map {200}, results
   end
@@ -149,7 +149,7 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
 
     duration = Time.now - started
 
-    assert duration < THRESHOLD, "Requests did not run concurrently under fiber scheduler (#{duration}s) which exceeds the expected threshold of: #{THRESHOLD} serial time would be about: #{SERIAL_TIME_WOULD_BE_ABOUT}"
+    assert_ran_concurrently(duration)
     assert_equal ITERS, results.size
     assert_equal ITERS.times.map {200}, results
   end
@@ -734,6 +734,97 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
     end
   end
 
+  # Records unblock calls in place of a real scheduler.
+  class UnblockRecorder
+    attr_reader :unblocked
+
+    def initialize
+      @unblocked = []
+    end
+
+    def unblock(blocker, _fiber)
+      @unblocked << blocker
+    end
+  end
+
+  # Enumerating every waiter on every drive-loop pass made release cost
+  # O(waiters) per pass; only the queued completions should be visited.
+  class NonEnumerableWaiters < Hash
+    %i[each each_pair each_value each_key].each do |name|
+      define_method(name) { |*| raise 'release_scheduler_waiters must not enumerate all waiters' }
+    end
+  end
+
+  def scheduler_test_waiter(scheduler)
+    {completed: true, done: false, error: nil, fiber: Fiber.new {}, scheduler: scheduler}
+  end
+
+  def test_release_scheduler_waiters_visits_only_queued_completions
+    state = Curl.scheduler_state
+    recorder = UnblockRecorder.new
+    waiters = NonEnumerableWaiters.new
+    1_000.times { |i| waiters[i] = scheduler_test_waiter(recorder).merge(completed: false) }
+    finished = scheduler_test_waiter(recorder)
+    waiters[:finished] = finished
+    state[:waiters] = waiters
+    state[:completed] << [:finished, finished]
+
+    Curl.release_scheduler_waiters(state)
+
+    assert_equal [finished], recorder.unblocked
+    assert finished[:done]
+    assert_empty state[:completed]
+  ensure
+    cleanup_scheduler_state
+  end
+
+  # A waiter whose perform already returned (it raised) is unregistered and its
+  # fiber may be blocked on something else, so a late completion must not
+  # unblock it.
+  def test_release_scheduler_waiters_skips_unregistered_waiter
+    state = Curl.scheduler_state
+    recorder = UnblockRecorder.new
+    stale = scheduler_test_waiter(recorder)
+    state[:completed] << [:stale, stale]
+
+    Curl.release_scheduler_waiters(state)
+
+    assert_empty recorder.unblocked
+    assert_equal false, stale[:done]
+    assert_empty state[:completed]
+  ensure
+    cleanup_scheduler_state
+  end
+
+  # The transfer whose callback raised the deferred exception receives that
+  # error rather than a normal completion; it stays queued so it is completed
+  # normally if the exception source changes.
+  def test_release_scheduler_waiters_holds_back_deferred_exception_source
+    state = Curl.scheduler_state
+    recorder = UnblockRecorder.new
+    source = scheduler_test_waiter(recorder)
+    sibling = scheduler_test_waiter(recorder)
+    state[:waiters][:source] = source
+    state[:waiters][:sibling] = sibling
+    state[:completed] << [:source, source] << [:sibling, sibling]
+    state[:multi].instance_variable_set(:@__curb_deferred_exception_source_id, :source)
+
+    Curl.release_scheduler_waiters(state)
+
+    assert_equal [sibling], recorder.unblocked
+    assert_equal false, source[:done]
+    assert_equal [[:source, source]], state[:completed]
+
+    state[:multi].remove_instance_variable(:@__curb_deferred_exception_source_id)
+    Curl.release_scheduler_waiters(state)
+
+    assert_equal [sibling, source], recorder.unblocked
+    assert source[:done]
+    assert_empty state[:completed]
+  ensure
+    cleanup_scheduler_state
+  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")
@@ -849,6 +940,14 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
     false
   end
 
+  # Wall-clock bounds are not reliable under valgrind, which slows and
+  # serializes threads unpredictably; there the requests and their results are
+  # still checked under memcheck, only the duration bound is skipped.
+  def assert_ran_concurrently(duration)
+    return if curb_under_valgrind?
+    assert duration < THRESHOLD, "Requests did not run concurrently under fiber scheduler (#{duration}s) which exceeds the expected threshold of: #{THRESHOLD} serial time would be about: #{SERIAL_TIME_WOULD_BE_ABOUT}"
+  end
+
   def socket_perform_supported?
     Curl::Multi.private_method_defined?(:_socket_perform)
   end

data/tests/tc_ractor.rb

@@ -0,0 +1,94 @@
+require File.expand_path('helper', __dir__)
+
+class TestCurbRactor < Test::Unit::TestCase
+  include TestServerMethods
+
+  RACTOR_WORKERS = 4
+  REQUESTS_PER_WORKER = 3
+
+  def setup
+    super
+    server_setup
+  end
+
+  def test_exported_string_constants_are_shareable
+    omit('Ractor is unavailable on this Ruby') unless defined?(Ractor)
+
+    %i[CURB_VERSION VERSION CURL_VERSION LONG_VERSION CURL_LONG_VERSION].each do |name|
+      value = Curl.const_get(name)
+      assert_predicate value, :frozen?, "Curl::#{name} should be frozen"
+      assert Ractor.shareable?(value), "Curl::#{name} should be Ractor-shareable"
+    end
+  end
+
+  def test_independent_ractors_can_perform_requests_concurrently
+    original_timeout = Curl::Multi.default_timeout
+    original_autoclose = Curl::Multi.autoclose
+    omit_unless_curb_ractor_safe
+
+    url = TestServlet.url
+
+    workers = RACTOR_WORKERS.times.map do |worker_id|
+      Ractor.new(url, worker_id, REQUESTS_PER_WORKER) do |target, id, request_count|
+        Curl.safe! { |config| config.protocols = [:http] }
+        Curl::Multi.default_timeout = 25 + id
+        Curl::Multi.autoclose = true
+
+        responses = request_count.times.map do
+          chunks = 0
+          easy = Curl::Easy.new(target)
+          easy.on_body do |data|
+            chunks += 1
+            data.bytesize
+          end
+          easy.perform
+          [easy.response_code, chunks]
+        end
+
+        {
+          responses: responses,
+          timeout: Curl::Multi.default_timeout,
+          autoclose: Curl::Multi.autoclose,
+          deferred_closes: Curl::Easy.deferred_multi_closes.length,
+          version: Curl::VERSION,
+        }
+      end
+    end
+
+    results = workers.map { |worker| ractor_value(worker) }
+
+    results.each_with_index do |result, worker_id|
+      assert_equal REQUESTS_PER_WORKER, result[:responses].length
+      result[:responses].each do |status, chunks|
+        assert_equal 200, status
+        assert_operator chunks, :>=, 1
+      end
+      assert_equal 25 + worker_id, result[:timeout]
+      assert_equal true, result[:autoclose]
+      assert_equal 0, result[:deferred_closes]
+      assert_equal Curl::VERSION, result[:version]
+    end
+
+    assert_equal original_timeout, Curl::Multi.default_timeout
+    assert_equal original_autoclose, Curl::Multi.autoclose
+  ensure
+    Curl::Multi.default_timeout = original_timeout if defined?(original_timeout)
+    Curl::Multi.autoclose = original_autoclose if defined?(original_autoclose)
+  end
+
+  private
+
+  def omit_unless_curb_ractor_safe
+    omit('Ractor is unavailable on this Ruby') unless defined?(Ractor)
+    omit('This build does not advertise Ractor-safe native support') unless
+      Curl.const_defined?(:RACTOR_SAFE) && Curl::RACTOR_SAFE
+  end
+
+  def ractor_value(ractor)
+    if ractor.respond_to?(:value)
+      ractor.value
+    else
+      ractor.take
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.3.7
+  version: 1.4.0
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
 bindir: bin
 cert_chain: []
-date: 2026-07-10 00:00:00.000000000 Z
+date: 2026-09-27 00:00:00.000000000 Z
 dependencies: []
 description: Curb (probably CUrl-RuBy or something) provides Ruby-language bindings
   for the libcurl(3), a fully-featured client-side URL transfer library. cURL and
@@ -78,6 +78,8 @@ files:
 - tests/tc_curl_easy_setopt.rb
 - tests/tc_curl_maxfilesize.rb
 - tests/tc_curl_multi.rb
+- tests/tc_curl_multi_poll.rb
+- tests/tc_curl_multi_socket_poller.rb
 - tests/tc_curl_native_coverage.rb
 - tests/tc_curl_network_policy.rb
 - tests/tc_curl_postfield.rb
@@ -85,6 +87,7 @@ files:
 - tests/tc_fiber_scheduler.rb
 - tests/tc_ftp_options.rb
 - tests/tc_gc_compact.rb
+- tests/tc_ractor.rb
 - tests/tc_test_server_methods.rb
 - tests/timeout.rb
 - tests/timeout_server.rb
@@ -148,6 +151,8 @@ test_files:
 - tests/tc_curl_easy_setopt.rb
 - tests/tc_curl_maxfilesize.rb
 - tests/tc_curl_multi.rb
+- tests/tc_curl_multi_poll.rb
+- tests/tc_curl_multi_socket_poller.rb
 - tests/tc_curl_native_coverage.rb
 - tests/tc_curl_network_policy.rb
 - tests/tc_curl_postfield.rb
@@ -155,6 +160,7 @@ test_files:
 - tests/tc_fiber_scheduler.rb
 - tests/tc_ftp_options.rb
 - tests/tc_gc_compact.rb
+- tests/tc_ractor.rb
 - tests/tc_test_server_methods.rb
 - tests/timeout.rb
 - tests/timeout_server.rb