wreq 1.2.11 → 1.2.13

data/test/fork_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rbconfig"
+require "tempfile"
+require "timeout"
+
+class ForkTest < Minitest::Test
+  FORK_ERROR_LABELS = %w[
+    module_request
+    fresh_client_request
+    fresh_body_sender_push
+    inherited_body_sender_push
+    inherited_body_sender_close
+    inherited_body_sender_closed
+    inherited_client
+    inherited_jar
+    inherited_cookie_provider
+    inherited_response_metadata
+    inherited_response
+    inherited_response_text
+    inherited_response_chunks
+    inherited_response_close
+  ].freeze
+
+  def test_fork_error_is_a_runtime_error
+    assert_operator Wreq::ForkError, :<, RuntimeError
+  end
+
+  def test_loaded_extension_can_initialize_runtime_after_fork
+    skip "fork is not supported on this platform" unless Process.respond_to?(:fork)
+
+    stdout, stderr, status = run_fork_script("prefork_runtime.rb")
+
+    assert status.success?, "subprocess failed with #{status.inspect}: #{stderr}"
+    assert_equal "ok\n", stdout
+    assert_match(/loaded_only=ok/, stderr)
+    assert_match(/before_runtime=ok/, stderr)
+    assert_match(/parent_after_children=ok/, stderr)
+    %w[
+      inherited_client_before_runtime
+      inherited_sender_before_runtime
+      inherited_jar_before_runtime
+      inherited_cookie_provider_before_runtime
+    ].each do |label|
+      assert_match(/#{label}=Wreq::ForkError:.*cannot be used after fork/, stderr)
+    end
+    refute_match(/\[BUG\]|segmentation fault|panicked/i, stderr)
+  end
+
+  def test_initialized_runtime_is_rejected_after_fork
+    skip "fork is not supported on this platform" unless Process.respond_to?(:fork)
+
+    stdout, stderr, status = run_fork_script("fork_safety.rb")
+
+    assert status.success?, "subprocess failed with #{status.inspect}: #{stderr}"
+    assert_equal "ok\n", stdout
+    assert_match(/non_runtime_construction=ok/, stderr)
+    assert_match(/inherited_snapshots=ok/, stderr)
+    FORK_ERROR_LABELS.each do |label|
+      assert_match(/#{label}=Wreq::ForkError:.*cannot be used after fork/, stderr)
+      assert_match(/#{label}_retry=Wreq::ForkError:.*cannot be used after fork/, stderr)
+    end
+    assert_match(/inherited_gc=ok/, stderr)
+    refute_match(/\[BUG\]|segmentation fault|panicked/i, stderr)
+  end
+
+  private
+
+  def run_fork_script(name)
+    lib_dir = File.expand_path("../lib", __dir__)
+    script = File.expand_path("scripts/#{name}", __dir__)
+
+    Tempfile.create("wreq-fork-stdout") do |stdout|
+      Tempfile.create("wreq-fork-stderr") do |stderr|
+        pid = Process.spawn(
+          RbConfig.ruby,
+          "-I",
+          lib_dir,
+          script,
+          out: stdout,
+          err: stderr,
+          pgroup: true
+        )
+        status = Timeout.timeout(30) { Process.wait2(pid).last }
+        stdout.rewind
+        stderr.rewind
+        return [stdout.read, stderr.read, status]
+      rescue Timeout::Error
+        begin
+          Process.kill("KILL", -pid)
+        rescue Errno::ESRCH
+          nil
+        end
+
+        begin
+          Process.wait(pid)
+        rescue Errno::ECHILD
+          nil
+        end
+
+        flunk "#{name} timed out"
+      end
+    end
+  end
+end

data/test/scripts/fork_safety.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+require "weakref"
+require "wreq"
+
+$stdout.sync = true
+$stderr.sync = true
+
+def expect_fork_error(label)
+  2.times do |attempt|
+    attempt_label = attempt.zero? ? label : "#{label}_retry"
+
+    begin
+      yield
+    rescue Wreq::ForkError => error
+      warn "#{attempt_label}=#{error.class}: #{error.message}"
+      next
+    rescue => error
+      abort "#{attempt_label}=unexpected #{error.class}: #{error.message}"
+    end
+
+    abort "#{attempt_label}=missing Wreq::ForkError"
+  end
+end
+
+server = TCPServer.new("127.0.0.1", 0)
+port = server.addr[1]
+server_pid = fork do
+  3.times do
+    ready = IO.select([server], nil, nil, 10)
+    exit! 4 unless ready
+
+    socket = server.accept
+    begin
+      while (line = socket.gets)
+        break if line == "\r\n"
+      end
+      socket.write("HTTP/1.1 200 OK\r\nX-Fork-Test: ok\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+    ensure
+      socket.close
+    end
+  end
+  exit! 0
+ensure
+  server.close
+end
+server.close
+
+url = "http://127.0.0.1:#{port}/"
+
+# Start the server process before Tokio creates worker threads in the parent.
+runtime_probe = Wreq::BodySender.new(1)
+runtime_probe.push("warmup")
+
+client = Wreq::Client.new
+abort "parent warm-up failed" unless client.get(url).bytes == "ok"
+
+inherited_objects = {
+  client: Wreq::Client.new,
+  sender: Wreq::BodySender.new,
+  response: client.get(url),
+  jar: Wreq::Jar.new
+}
+inherited_weak_refs = inherited_objects.values.map { |object| WeakRef.new(object) }
+status_snapshot = inherited_objects[:response].status
+headers_snapshot = inherited_objects[:response].headers
+
+guard_pid = fork do
+  Timeout.timeout(10) do
+    jar = Wreq::Jar.new
+    jar.add("child=1; Path=/", url)
+    abort "fresh child jar failed" unless jar.get_all.one?
+
+    Wreq::Client.new(cookie_provider: jar)
+    Wreq::BodySender.new
+    warn "non_runtime_construction=ok"
+
+    abort "status snapshot changed" unless status_snapshot.to_i == 200
+    abort "headers snapshot changed" unless headers_snapshot["X-Fork-Test"] == "ok"
+    warn "inherited_snapshots=ok"
+
+    expect_fork_error("module_request") { Wreq.get(url) }
+    expect_fork_error("fresh_client_request") { Wreq::Client.new.get(url) }
+    expect_fork_error("fresh_body_sender_push") { Wreq::BodySender.new.push("chunk") }
+    expect_fork_error("inherited_body_sender_push") do
+      inherited_objects[:sender].push("chunk")
+    end
+    expect_fork_error("inherited_body_sender_close") { inherited_objects[:sender].close }
+    expect_fork_error("inherited_body_sender_closed") { inherited_objects[:sender].closed? }
+    expect_fork_error("inherited_client") { inherited_objects[:client].get(url) }
+    expect_fork_error("inherited_jar") { inherited_objects[:jar].get_all }
+    expect_fork_error("inherited_cookie_provider") do
+      Wreq::Client.new(cookie_provider: inherited_objects[:jar])
+    end
+    expect_fork_error("inherited_response_metadata") { inherited_objects[:response].status }
+    expect_fork_error("inherited_response") { inherited_objects[:response].bytes }
+    expect_fork_error("inherited_response_text") { inherited_objects[:response].text }
+    expect_fork_error("inherited_response_chunks") { inherited_objects[:response].chunks { nil } }
+    expect_fork_error("inherited_response_close") { inherited_objects[:response].close }
+  end
+  exit! 0
+rescue => error
+  warn "guard_checks=unexpected #{error.class}: #{error.message}"
+  exit! 2
+end
+_, guard_status = Process.wait2(guard_pid)
+abort "guard checks child failed with #{guard_status.inspect}" unless guard_status.success?
+
+# The hash is now the only strong reference to the inherited native objects.
+GC.start(full_mark: true, immediate_sweep: true)
+gc_pid = fork do
+  inherited_objects = nil
+  3.times { GC.start(full_mark: true, immediate_sweep: true) }
+  alive = inherited_weak_refs.each_index.select do |index|
+    inherited_weak_refs[index].weakref_alive?
+  end
+  abort "inherited objects were not collected: #{alive.join(", ")}" unless alive.empty?
+  warn "inherited_gc=ok"
+  exit! 0
+rescue => error
+  warn "inherited_gc=unexpected #{error.class}: #{error.message}"
+  exit! 5
+end
+_, gc_status = Process.wait2(gc_pid)
+abort "inherited GC child failed with #{gc_status.inspect}" unless gc_status.success?
+
+abort "parent request after fork failed" unless client.get(url).bytes == "ok"
+_, server_status = Process.wait2(server_pid)
+abort "server failed with #{server_status.inspect}" unless server_status.success?
+
+puts "ok"

data/test/scripts/prefork_runtime.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+require "wreq"
+
+$stdout.sync = true
+$stderr.sync = true
+
+def expect_fork_error(label)
+  yield
+  abort "#{label}=missing Wreq::ForkError"
+rescue Wreq::ForkError => error
+  warn "#{label}=#{error.class}: #{error.message}"
+end
+
+def run_child(label)
+  child_pid = fork do
+    Timeout.timeout(10) { yield }
+    warn "#{label}=ok"
+    exit! 0
+  rescue => error
+    warn "#{label}=unexpected #{error.class}: #{error.message}"
+    exit! 2
+  end
+
+  _, status = Process.wait2(child_pid)
+  abort "#{label} child failed with #{status.inspect}" unless status.success?
+end
+
+server = TCPServer.new("127.0.0.1", 0)
+url = "http://127.0.0.1:#{server.addr[1]}/"
+server_pid = fork do
+  3.times do
+    ready = IO.select([server], nil, nil, 10)
+    exit! 4 unless ready
+
+    socket = server.accept
+    begin
+      while (line = socket.gets)
+        break if line == "\r\n"
+      end
+      socket.write("HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+    ensure
+      socket.close
+    end
+  end
+  exit! 0
+ensure
+  server.close
+end
+server.close
+
+# Requiring the extension is the only parent-side Wreq operation before this fork.
+run_child("loaded_only") do
+  abort "module request failed" unless Wreq.get(url).bytes == "ok"
+end
+
+inherited_client = Wreq::Client.new
+inherited_sender = Wreq::BodySender.new
+inherited_jar = Wreq::Jar.new
+
+run_child("before_runtime") do
+  expect_fork_error("inherited_client_before_runtime") do
+    inherited_client.get(url)
+  end
+  expect_fork_error("inherited_sender_before_runtime") { inherited_sender.closed? }
+  expect_fork_error("inherited_jar_before_runtime") { inherited_jar.get_all }
+  expect_fork_error("inherited_cookie_provider_before_runtime") do
+    Wreq::Client.new(cookie_provider: inherited_jar)
+  end
+
+  sender = Wreq::BodySender.new
+  sender.push("child")
+
+  jar = Wreq::Jar.new
+  jar.add("child=1; Path=/", url)
+  abort "child jar failed" unless jar.get_all.one?
+
+  client = Wreq::Client.new(cookie_provider: jar)
+  abort "client request failed" unless client.get(url).bytes == "ok"
+end
+
+Timeout.timeout(10) do
+  abort "parent client failed" unless inherited_client.get(url).bytes == "ok"
+  inherited_sender.push("parent")
+  inherited_jar.add("parent=1; Path=/", url)
+  abort "parent jar failed" unless inherited_jar.get_all.one?
+end
+warn "parent_after_children=ok"
+
+_, server_status = Process.wait2(server_pid)
+abort "server failed with #{server_status.inspect}" unless server_status.success?
+
+puts "ok"

data/test/support/tls_server.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "socket"
+require "timeout"
+
+# A small HTTPS server that serves every expected request on one TLS connection.
+module TlsTestServer
+  RESPONSE_BODY = "ok"
+
+  module_function
+
+  def with_connection(request_count:)
+    tcp_server = TCPServer.new("127.0.0.1", 0)
+    context, certificate_der = server_context
+    ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, context)
+    outcome = Queue.new
+    server_thread = Thread.new do
+      socket = ssl_server.accept
+      request_lines = []
+
+      request_count.times do |index|
+        request_lines << read_request(socket)
+        connection = (index == request_count - 1) ? "close" : "keep-alive"
+        socket.write(response(connection))
+        socket.flush
+      end
+
+      outcome << {connections: 1, requests: request_lines}
+    rescue => error
+      outcome << error
+    ensure
+      socket&.close
+    end
+    server_thread.report_on_exception = false
+
+    yield "https://127.0.0.1:#{tcp_server.addr[1]}/", certificate_der
+
+    result = Timeout.timeout(5) { outcome.pop }
+    raise result if result.is_a?(StandardError)
+
+    result
+  ensure
+    tcp_server&.close
+    server_thread&.join(5)
+    if server_thread&.alive?
+      server_thread.kill
+      server_thread.join
+    end
+  end
+
+  def read_request(socket)
+    request_line = socket.gets
+    raise EOFError, "client closed before sending a request" unless request_line
+
+    loop do
+      line = socket.gets
+      raise EOFError, "client closed while sending headers" unless line
+      break if line == "\r\n"
+    end
+
+    request_line
+  end
+  private_class_method :read_request
+
+  def response(connection)
+    [
+      "HTTP/1.1 200 OK",
+      "Content-Length: #{RESPONSE_BODY.bytesize}",
+      "Connection: #{connection}",
+      "",
+      RESPONSE_BODY
+    ].join("\r\n")
+  end
+  private_class_method :response
+
+  def server_context
+    key = OpenSSL::PKey::RSA.new(2048)
+    certificate = OpenSSL::X509::Certificate.new
+    certificate.version = 2
+    certificate.serial = 1
+    certificate.subject = certificate.issuer = OpenSSL::X509::Name.parse("/CN=127.0.0.1")
+    certificate.public_key = key.public_key
+    certificate.not_before = Time.now - 60
+    certificate.not_after = Time.now + 3600
+    certificate.sign(key, OpenSSL::Digest.new("SHA256"))
+
+    context = OpenSSL::SSL::SSLContext.new.tap do |ssl_context|
+      ssl_context.cert = certificate
+      ssl_context.key = key
+    end
+    [context, certificate.to_der]
+  end
+  private_class_method :server_context
+end

data/test/tls_info_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require_relative "support/tls_server"
+
+class TlsInfoTest < Minitest::Test
+  HTTPBIN_HTTP_URL = ENV.fetch("HTTPBIN_HTTP_URL", HTTPBIN_URL.sub(/\Ahttps:/, "http:"))
+
+  def test_tls_info_is_nil_when_disabled_or_request_is_plain_http
+    default_response = Wreq::Client.new.get("#{HTTPBIN_URL}/get")
+    plain_response = Wreq::Client.new(tls_info: true).get("#{HTTPBIN_HTTP_URL}/get")
+
+    assert_nil default_response.tls_info
+    assert_nil plain_response.tls_info
+  end
+
+  def test_certificate_data_survives_body_lifecycle_on_a_reused_connection
+    fixture = TlsTestServer.with_connection(request_count: 2) do |base_url, certificate_der|
+      client = Wreq::Client.new(
+        tls_info: true,
+        verify: false,
+        http1_only: true,
+        no_proxy: true,
+        timeout: 5
+      )
+
+      read_response = client.get("#{base_url}read")
+      assert_equal "ok", read_response.text
+      read_tls = read_response.tls_info
+
+      closed_response = client.get("#{base_url}close")
+      closed_response.close
+      closed_tls = closed_response.tls_info
+
+      assert_instance_of Wreq::TlsInfo, read_tls
+      certificate = read_tls.peer_certificate
+      chain = read_tls.peer_certificate_chain
+      assert_equal certificate_der, certificate
+      assert_equal Encoding::BINARY, certificate.encoding
+      assert_equal [certificate_der], chain
+      assert_equal Encoding::BINARY, chain.first.encoding
+      assert_predicate chain, :frozen?
+      assert_equal(
+        "#<Wreq::TlsInfo peer_certificate=#{certificate_der.bytesize}B peer_certificate_chain=1>",
+        read_tls.inspect
+      )
+      assert_empty Wreq::TlsInfo.instance_methods(false) & %i[to_h to_s]
+
+      certificate.clear
+      assert_equal certificate_der, read_tls.peer_certificate
+      assert_equal certificate_der, closed_tls.peer_certificate
+    end
+
+    assert_equal(
+      {connections: 1, requests: ["GET /read HTTP/1.1\r\n", "GET /close HTTP/1.1\r\n"]},
+      fixture
+    )
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.2.11
+  version: 1.2.13
 platform: ruby
 authors:
 - SearchApi
@@ -80,6 +80,8 @@ files:
 - crates/wreq-util/tests/emulate_safari.rs
 - crates/wreq-util/tests/support/mod.rs
 - crates/wreq-util/tests/support/server.rs
+- docs/fork-safety.md
+- docs/interrupt-handling.md
 - docs/windows-gnu-tokio-crash.md
 - examples/body.rb
 - examples/client.rb
@@ -90,6 +92,7 @@ files:
 - examples/send_stream.rb
 - examples/stream.rb
 - examples/thread_interrupt.rb
+- examples/tls_info.rb
 - extconf.rb
 - lib/wreq.rb
 - lib/wreq_ruby/body.rb
@@ -100,6 +103,7 @@ files:
 - lib/wreq_ruby/header.rb
 - lib/wreq_ruby/http.rb
 - lib/wreq_ruby/response.rb
+- lib/wreq_ruby/tls.rb
 - script/build_platform_gem.rb
 - script/rust_env.rb
 - src/arch.rs
@@ -142,12 +146,14 @@ files:
 - src/serde/ser/struct_variant_serializer.rs
 - src/serde/ser/tuple_variant_serializer.rs
 - src/serde/tests.rs
+- src/tls.rs
 - test/body_sender_test.rb
 - test/client_cookie_test.rb
 - test/client_test.rb
 - test/cookie_test.rb
 - test/emulation_test.rb
 - test/error_handling_test.rb
+- test/fork_test.rb
 - test/header_test.rb
 - test/inspect_test.rb
 - test/json_precision_test.rb
@@ -157,8 +163,12 @@ files:
 - test/request_parameters_test.rb
 - test/request_test.rb
 - test/response_test.rb
+- test/scripts/fork_safety.rb
+- test/scripts/prefork_runtime.rb
 - test/stream_test.rb
+- test/support/tls_server.rb
 - test/test_helper.rb
+- test/tls_info_test.rb
 - test/value_semantics_test.rb
 - wreq.gemspec
 homepage: https://github.com/SearchApi/wreq-ruby