dnsruby 1.73.1 → 2.0.0

data/test/tc_tcp_pipelining.rb

@@ -15,241 +15,132 @@
 # ++
 
 require_relative 'spec_helper'
-require_relative 'test_dnsserver'
-
-# The TCPPipeliningServer links our NioTcpPipeliningHandler on
-# the loopback interface.
-class TCPPipeliningServer < Async::DNS::Server
-  PORT     = 53937
-  IP   = '127.0.0.1'
-
-  DEFAULT_MAX_REQUESTS = 4
-  DEFAULT_TIMEOUT = 3
-
-  @@stats = Stats.new
-
-  def self.stats
-    @@stats
-  end
-
-  def initialize(**options)
-    super(options)
-
-    @handlers = []
-    @handlers << NioTcpPipeliningHandler.new(self, IP, PORT, DEFAULT_MAX_REQUESTS, DEFAULT_TIMEOUT) #4 max request
-  end
-
-  def process(name, resource_class, transaction)
-    @logger.debug "name: #{name}"
-    transaction.respond!("93.184.216.34", { resource_class: ::Resolv::DNS::Resource::IN::A })
-  end
-
-end
+require_relative 'tcp_pipelining_server'
+require 'timeout'
 
 class TestTCPPipelining < Minitest::Test
-
-  class << self
-    attr_accessor :query_id
-  end
-
-  def self.init
-    unless @initialized
-      @initialized = true
-      @query_id = 0
-    end
-  end
-
-  @@server = nil
+  WAIT_TIMEOUT = 5
 
   def setup
-  return
-    self.class.init
-
-    # Instantiate a new server that uses our tcp pipelining handler
-    # For each query the server sends the query upstream (193.0.14.129)
-    # options = {
-    #     server_class: TCPPipeliningServer,
-    # }
-
-    #RubyDNS::run_server(options) || true
-    if !@@server
-      @@server = TCPPipeliningServer.new()
-
-      Thread.new do
-        @@server.run
-      end
-    end
-
-    # Instantiate our resolver. The resolver will use the same pipeline as much as possible.
-    # If a timeout occurs or max_request_per_connection a new connection should be initiated
-    @@resolver ||= Dnsruby::Resolver.new(
-        use_tcp:                    true,
-        do_caching:                 false,
-        tcp_pipelining:             true,
-        dnssec:                     false,
-        packet_timeout:             10,
-        tcp_pipelining_max_queries: 10,
-        nameserver:                 TCPPipeliningServer::IP,
-        port:                       TCPPipeliningServer::PORT)
+    @server = PipelineTest::Server.new
+    @query_id = 0
+    @resolver = Dnsruby::Resolver.new(
+      use_tcp: true,
+      do_caching: false,
+      tcp_pipelining: true,
+      dnssec: false,
+      retry_times: 1,
+      packet_timeout: WAIT_TIMEOUT,
+      query_timeout: WAIT_TIMEOUT,
+      tcp_pipelining_max_queries: 10,
+      nameserver: PipelineTest::Server::IP,
+      port: @server.port
+    )
   end
 
-  # Send x number of queries asynchronously to our resolver
-  def send_async_messages(number_of_messages, queue, wait_seconds = 0)
-    Dnsruby.log.debug "Sending #{number_of_messages} messages"
-    number_of_messages.times do
-      name = "#{self.class.query_id}.com"
-      Dnsruby.log.debug "Sending #{name}"
-      message = Dnsruby::Message.new(name)
-      # self.class.query_id identifies our query, must be different for each message
-      @@resolver.send_async(message, queue, self.class.query_id)
-      self.class.query_id += 1
+  def teardown
+    @resolver.close if @resolver
+  ensure
+    @server.stop if @server
+    wait_for_client_close if @resolver
+  end
 
-      # Note: For 0, we don't sleep at all instead of sleeping 0 since sleeping 0
-      # involves yielding the CPU.
-      sleep wait_seconds unless wait_seconds == 0
+  def send_async_messages(count, queue)
+    Array.new(count) do
+      id = @query_id
+      @query_id += 1
+      message = Dnsruby::Message.new("pipeline-#{id}.example.invalid")
+      message.do_caching = false
+      message.do_validation = false
+      @resolver.send_async(message, queue, id)
+      id
     end
   end
 
-  # Verify x responses with no exception
-  def verify_responses(number_of_messages, queue)
-    number_of_messages.times do
-      _response_id, response, exception = queue.pop
-      assert_nil(exception)
-      assert(response.is_a?(Dnsruby::Message))
+  def responses_for(ids, queue)
+    responses = Timeout.timeout(WAIT_TIMEOUT + 1) do
+      Array.new(ids.length) { queue.pop }
     end
+    @server.stats # Propagate any exception in the server thread.
+    assert_equal ids.sort, responses.map(&:first).sort
+    responses.sort_by(&:first)
   end
 
-  def accept_wait(accept_count, max)
-    i = 0
-    while TCPPipeliningServer.stats.accept_count < accept_count
-      sleep 0.5
-      i+=0.5
-      assert(i<max, "Max wait for accept reached #{TCPPipeliningServer.stats.accept_count} accepts < #{accept_count}")
+  def verify_responses(ids, queue)
+    responses_for(ids, queue).each do |id, response, exception|
+      assert_nil exception
+      assert_instance_of Dnsruby::Message, response
+      assert_equal "pipeline-#{id}.example.invalid", response.question.first.qname.to_s
+      assert_equal PipelineTest::Server::ANSWER, response.answer.first.address.to_s
     end
   end
 
-  def connection_wait(connection_count, max)
-    i = 0
-    while TCPPipeliningServer.stats.connections > connection_count
-      sleep 0.5
-      i+=0.5
-      assert(i<max, "Max wait for connection reached: #{TCPPipeliningServer.stats.connections} active connections > #{connection_count}")
+  def wait_for_timeouts(count)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + WAIT_TIMEOUT
+    until @server.stats[:timeouts] == count && @server.stats[:connections].zero?
+      flunk "Timed out waiting for #{count} connection expiry/expiries: #{@server.stats}" if
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+      sleep 0.01
     end
+    # A server-side close does not mean the client's select thread has seen
+    # the FIN yet. Reconnect only after it has processed EOF.
+    wait_for_client_close
   end
 
-  def timeout_wait(timeout_count, max)
-    i = 0
-    while TCPPipeliningServer.stats.timeout_count < timeout_count
-      sleep 0.5
-      i+=0.5
-      assert(i<max, "Max wait for timeout reached #{TCPPipeliningServer.stats.timeout_count} timeounts < #{timeout_count}")
+  def wait_for_client_close
+    sender = @resolver.single_resolvers.first
+    socket = sender.instance_variable_get(:@pipeline_socket)
+    Timeout.timeout(WAIT_TIMEOUT) do
+      sleep 0.01 while socket && !socket.closed?
     end
   end
 
-  # This test initiates multiple asynchronous requests and verifies they go on the same tcp
-  # pipeline or a new one depending on timeouts
+  # Multiple outstanding queries share one TCP connection; after it expires,
+  # the next batch must use a new connection.
   def test_TCP_pipelining_timeout
-  return
-    Dnsruby.log.debug "test_TCP_pipelining_timeout"
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-
-    accept_count  = TCPPipeliningServer.stats.accept_count
-    timeout_count = TCPPipeliningServer.stats.timeout_count
-
-    # This is the main queue used to communicate between Dnsruby in async mode and the client
-    query_queue = Queue.new
-
-    # Test basic pipelining. All request should go on the same tcp connection.
-    # TCPPipeliningServer.stats.accept_count should be 1.
-    send_async_messages(3, query_queue)
-    verify_responses(3, query_queue)
-
-    assert_equal(accept_count + 1, TCPPipeliningServer.stats.accept_count)
-
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-    timeout_wait(timeout_count + 1, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-
-    assert_equal(timeout_count + 1, TCPPipeliningServer.stats.timeout_count)
-
-    # Initiate another 3 queries, check accept_count and timeout_count
-    send_async_messages(3, query_queue)
-    verify_responses(3, query_queue)
-
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-    timeout_wait(timeout_count + 2, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-
-    assert_equal(accept_count + 2, TCPPipeliningServer.stats.accept_count)
-    assert_equal(timeout_count + 2, TCPPipeliningServer.stats.timeout_count)
-
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
+    queue = Queue.new
+    verify_responses(send_async_messages(3, queue), queue)
+    assert_equal 1, @server.stats[:accepts]
+    wait_for_timeouts(1)
+
+    verify_responses(send_async_messages(3, queue), queue)
+    assert_equal 2, @server.stats[:accepts]
+    wait_for_timeouts(2)
+    assert_equal 2, @server.stats[:timeouts]
   end
 
-  # Test timeout occurs and new connection is initiated inbetween 2 sends
+  # The server closes the pipeline between sends, and a single subsequent
+  # query must reconnect successfully.
   def test_TCP_pipelining_timeout_in_send
-  return
-    Dnsruby.log.debug "test_TCP_pipelining_timeout_in_send"
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-
-    accept_count  = TCPPipeliningServer.stats.accept_count
-    timeout_count = TCPPipeliningServer.stats.timeout_count
-
-    query_queue = Queue.new
-
-    # Initiate another 2 queries wait and then send a final query
-    # Check accept_count. Wait for timeout and verify we got 2 additional timeouts.
-    send_async_messages(2, query_queue)
-    verify_responses(2, query_queue)
-
-    accept_wait(accept_count+1, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-
-    send_async_messages(1, query_queue)
-
-    verify_responses(1, query_queue)
-
-    assert_equal(accept_count + 2, TCPPipeliningServer.stats.accept_count)
-
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-
-    timeout_wait(timeout_count + 2, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
+    queue = Queue.new
+    verify_responses(send_async_messages(2, queue), queue)
+    assert_equal 1, @server.stats[:accepts]
+    wait_for_timeouts(1)
+
+    verify_responses(send_async_messages(1, queue), queue)
+    assert_equal 2, @server.stats[:accepts]
+    wait_for_timeouts(2)
+    assert_equal 2, @server.stats[:timeouts]
   end
 
-  # Test that we get a SocketEofResolvError if the servers closes the socket before
-  # all queries are answered
+  # The peer answers only four of six outstanding queries before closing.
+  # Each unanswered query must receive EOF, rather than a resolver timeout.
   def test_TCP_pipelining_socket_eof
-  return
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
-
-    query_queue = Queue.new
-
-    # Issue 6 queries. Only 4 should be replied since max_request_per_connection = 4
-    # Verify we get Dnsruby::SocketEofResolvError on the last 2.
-    # Verify we got max_count was incremented
-    send_async_messages(6, query_queue)
-
-    responses = []
-
-    6.times do
-      response = query_queue.pop
-      responses << response
-    end
-
-    responses.sort_by { |response| response[0] }
-
-    step = 0
-
-    responses.each do | response |
-      _response_id, response, exception = response
-      if step < TCPPipeliningServer::DEFAULT_MAX_REQUESTS
-        assert_nil(exception, "Exception not nil for msg #{step} < #{TCPPipeliningServer::DEFAULT_MAX_REQUESTS} requests")
-        assert(response.is_a?(Dnsruby::Message))
+    queue = Queue.new
+    ids = send_async_messages(6, queue)
+    responses_for(ids, queue).each do |id, response, exception|
+      if id < PipelineTest::Server::MAX_REQUESTS
+        assert_nil exception
+        assert_instance_of Dnsruby::Message, response
+        assert_equal "pipeline-#{id}.example.invalid", response.question.first.qname.to_s
+        assert_equal PipelineTest::Server::ANSWER, response.answer.first.address.to_s
       else
-        assert_equal(Dnsruby::SocketEofResolvError, exception.class)
-        assert_nil(response)
+        assert_instance_of Dnsruby::SocketEofResolvError, exception
+        assert_nil response
       end
-      step += 1
     end
-
-    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
+    wait_for_timeouts(1)
+    assert_equal 1, @server.stats[:accepts]
+    assert_equal 1, @server.stats[:limits]
   end
 end

data/test/tc_transport_fork.rb

@@ -0,0 +1,179 @@
+require_relative 'spec_helper'
+require 'open3'
+require 'rbconfig'
+
+class TestTransportFork < Minitest::Test
+  def test_child_discards_parent_transactions_descriptors_and_worker_state
+    skip 'fork unavailable' unless Process.respond_to?(:fork)
+    code = <<~'CHILD'
+      require 'dnsruby'
+      require 'timeout'
+      Dnsruby.log.level = Logger::FATAL
+      # Own dispatch explicitly: no DNS service or elapsed timeout is needed.
+      class Dnsruby::SelectThread
+        def get_socket_pair
+          Socket.pair(:UNIX, :STREAM, 0)
+        end
+
+        def do_select
+          sleep
+        end
+      end
+      Timeout.timeout(10) do
+        selector = Dnsruby::SelectThread.instance
+        klass = Dnsruby::SelectThread
+        resolver = Dnsruby::Resolver.new(nameserver: '127.0.0.1', dnssec: false)
+        sender = resolver.single_resolvers.first
+        sender.define_singleton_method(:send_async) { |*| }
+        request = Dnsruby::Message.new('fork.example.')
+        request.do_caching = request.do_validation = false
+        results = Queue.new
+        resolver.send_async(request, results, :reused)
+        engine = resolver.instance_variable_get(:@resolver_ruby)
+        inherited_attempt = engine.instance_variable_get(:@query_list)[:reused][3].first
+        socket, peer = Socket.pair(:UNIX, :STREAM, 0)
+        pending_socket, pending_peer = Socket.pair(:UNIX, :STREAM, 0)
+        selector.track_socket(pending_socket) # A socket still connecting/writing.
+        settings = klass::QuerySettings.new(request.encode, request, false, Queue.new,
+          :parent_stream, socket, '127.0.0.1', 53, Dnsruby::TransportClock.now + 60, 512, sender)
+        settings.is_persistent_socket = true
+        settings.tcp_pipelining_max_queries = :infinite
+        selector.add_to_select(settings)
+        sender.instance_variable_set(:@pipeline_socket, socket)
+        sender.instance_variable_set(:@use_counts, { socket => 1 })
+        writer_lock = Mutex.new
+        writer_lock.lock
+        sender.instance_variable_set(:@pipeline_mutex, writer_lock)
+        wakeups = klass.class_variable_get(:@@wakeup_sockets).dup
+        started, release = Queue.new, Queue.new
+        selector.defer_send(sender) { started << true; release.pop }
+        started.pop
+
+        child_status = ForkTestHelper.run do
+          begin
+            # A retained reference must be as safe as fetching the singleton.
+            raise 'inherited transaction survived' if selector.query_settings_for_id(:parent_stream)
+            raise 'singleton changed' unless Dnsruby::SelectThread.instance.equal?(selector)
+            raise 'inherited descriptors open' unless ([socket, pending_socket] + wakeups).all?(&:closed?)
+            [:query_hash, :socket_hash, :timeouts, :observers, :observer_queue_counts,
+              :tcp_buffers, :socket_owners, :socket_remaining_queries,
+              :queued_exceptions, :queued_responses, :queued_validation_responses,
+              :validations, :tick_observers].each do |name|
+              raise "inherited #{name}" unless klass.class_variable_get("@@#{name}").empty?
+            end
+            raise 'inherited sockets still selected' unless klass.class_variable_get(:@@sockets).size == 1
+            raise 'new wakeup pair unavailable' unless klass.class_variable_get(:@@wakeup_sockets).none?(&:closed?)
+            raise 'inherited workers retained' if selector.instance_variable_get(:@send_workers)
+            selector.defer_send(sender) { :child_work }.value == :child_work or raise 'new worker failed'
+
+            # A real pipeline send must choose a child-owned connection before
+            # taking the writer lock that the parent held when it forked.
+            child_socket, child_peer = Socket.pair(:UNIX, :STREAM, 0)
+            sender.tcp_pipelining = true
+            sender.define_singleton_method(:connect_tcp) do |*|
+              selector.track_socket(child_socket)
+            end
+            direct_results = Queue.new
+            sender.send_dnsruby(request.encode, request, :child_stream, direct_results, true)
+            raise 'child did not open its own pipeline' unless sender.instance_variable_get(:@pipeline_socket).equal?(child_socket)
+            raise 'inherited writer mutex retained' if sender.instance_variable_get(:@pipeline_mutex).equal?(writer_lock)
+            raise 'inherited use counts retained' if sender.instance_variable_get(:@use_counts).key?(socket)
+            frame_size = child_peer.read(2).unpack1('n')
+            child_request = Dnsruby::Message.decode(child_peer.read(frame_size))
+            raise 'child frame incorrect' unless child_request.question == request.question
+            direct_answer = request.clone
+            direct_answer.header.qr = true
+            selector.process_message(direct_answer, direct_answer.encode, child_socket)
+            selector.send_queued_validation_responses
+            raise 'child pipeline response failed' unless direct_results.size == 2 &&
+              2.times.map { direct_results.pop }.all? { |event| event.last.nil? }
+            sender.close
+            child_peer.close
+
+            # Resolver IDs also belong to the parent and can be reused by child
+            # transactions without delivering a spurious duplicate-ID failure.
+            resolver.send_async(request.clone, results, :reused)
+            current = engine.instance_variable_get(:@query_list)[:reused]
+            raise 'child query rejected' unless current && results.empty?
+            pending = selector.query_settings_for_id(current[3].first)
+            raise 'child attempt absent' unless pending
+            answer = request.clone
+            answer.header.qr = true
+            answer.add_answer(Dnsruby::RR.create('fork.example. 60 IN A 192.0.2.1'))
+            selector.push_response_for_query(pending, answer, pending.query, sender)
+            selector.send_queued_responses
+            raise 'child completion failed' unless results.size == 1 && results.pop.last.nil?
+            resolver.close
+            exit! 0
+          rescue Exception => error
+            warn error.full_message
+            exit! 1
+          end
+        end
+        raise 'fork child failed' unless child_status.success?
+        raise 'parent descriptor closed' if ([socket, pending_socket] + wakeups).any?(&:closed?)
+        raise 'parent transaction discarded' unless selector.query_settings_for_id(inherited_attempt)
+        raise 'parent observer discarded' unless klass.class_variable_get(:@@observers).size == 1
+        raise 'parent received child result' unless results.empty?
+        peer.write('parent')
+        raise 'parent connection damaged' unless socket.read(6) == 'parent'
+        release << true
+        writer_lock.unlock
+        resolver.close
+        [socket, peer, pending_socket, pending_peer].each { |io| io.close unless io.closed? }
+      end
+    CHILD
+    source = "require #{File.expand_path('fork_test_helper', __dir__).inspect}\n#{code}"
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, '-I',
+      File.expand_path('../lib', __dir__), '-e', source)
+    assert(status.success?, "#{stdout}\n#{stderr}")
+    assert_empty(stderr)
+  end
+
+  def test_fork_timeout_reaps_the_child_and_closes_its_output_pipes
+    skip 'fork unavailable' unless Process.respond_to?(:fork)
+    source = <<~RUBY
+      require #{File.expand_path('fork_test_helper', __dir__).inspect}
+      # Start the timer service before forking, as the transport tests do.
+      Timeout.timeout(3) do
+        status = ForkTestHelper.run(timeout: 0.05) { sleep }
+        raise 'stalled child reported success' unless status.exitstatus == 1
+      end
+      begin
+        Process.wait(-1, Process::WNOHANG)
+        raise 'child was not reaped'
+      rescue Errno::ECHILD
+      end
+    RUBY
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, '-e', source)
+    assert(status.success?, "#{stdout}\n#{stderr}")
+    assert_match(/Timeout::Error/, stderr)
+  end
+
+  def test_parent_interruption_also_reaps_its_waiting_child
+    skip 'fork unavailable' unless Process.respond_to?(:fork)
+    source = <<~RUBY
+      require #{File.expand_path('fork_test_helper', __dir__).inspect}
+      class ParentInterrupted < StandardError; end
+      # This thread exists only in the parent, so the child cannot inherit
+      # a pending Timeout request and finish before the parent is interrupted.
+      interrupter = Thread.new { sleep 0.1; Thread.main.raise ParentInterrupted }
+      begin
+        ForkTestHelper.run { sleep }
+        raise 'parent was not interrupted'
+      rescue ParentInterrupted
+      ensure
+        interrupter.kill
+        interrupter.join
+      end
+      begin
+        Process.wait(-1, Process::WNOHANG)
+        raise 'child was not reaped'
+      rescue Errno::ECHILD
+      end
+    RUBY
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, '-e', source)
+    assert(status.success?, "#{stdout}\n#{stderr}")
+    assert_empty(stderr)
+  end
+end

data/test/tc_tsig.rb

@@ -16,11 +16,11 @@
 
 require_relative 'spec_helper'
 
-require "digest/md5"
 class TestTSig < Minitest::Test
 
   include Dnsruby
 
+  # The online fixture must configure this key for HMAC-SHA256 on the server.
   KEY_NAME="rubytsig"
   KEY = "8n6gugn4aJ7MazyNlMccGKH1WxD2B3UvN/O/RA6iBupO2/03u9CTa3Ewz3gBWTSBCH3crY4Kk+tigNdeJBAvrw=="
   def is_empty(string)
@@ -52,7 +52,7 @@ class TestTSig < Minitest::Test
         :type        => "TSIG",
         :ttl         => 0,
         :klass       => "ANY",
-        :algorithm   => "hmac-md5",
+        :algorithm   => "hmac-sha256",
         :fudge       => 300,
         :key         => KEY,
         :error       => 0