dnsruby 1.57.0 → 1.58.0

data/test/tc_soak_base.rb

@@ -20,25 +20,25 @@ class TestSoakBase # < Minitest::Test
   include Dnsruby
   Rrs = [
   {
-    :type   		=> Types.A,
-    :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :address 	=> '10.0.1.128'
+    :type       => Types.A,
+    :name       => 'ns1.google.com.',
+    :address    => '10.0.1.128'
   },
   {
-    :type		=> Types::MX,
-    :name		=> 'mx.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :exchange	=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :preference 	=> 10
+    :type       => Types::MX,
+    :name       => 'ns1.google.com.',
+    :exchange   => 'ns1.google.com.',
+    :preference => 10
   },
   {
-    :type		=> 'CNAME',
-    :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
+    :type       => 'CNAME',
+    :name       => 'ns1.google.com.',
+    :domainname => 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
   },
   {
-    :type		=> Types.TXT,
-    :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :strings		=> ['Net-DNS']
+    :type       => Types.TXT,
+    :name       => 'ns1.google.com.',
+    :strings    => ['Net-DNS']
   }
   ]
 
@@ -92,7 +92,7 @@ class TestSoakBase # < Minitest::Test
     assert(num_in_progress==0)
     stop=Time.now
     time_taken=stop-start
-    p "Query count : #{num_sent}, #{timed_out} timed out. #{time_taken} time taken"
+    puts "Query count : #{num_sent}, #{timed_out} timed out. #{time_taken} time taken"
     assert(timed_out < num_sent * 0.1, "#{timed_out} of #{num_sent} timed out!")
   end
 
@@ -143,7 +143,7 @@ class TestSoakBase # < Minitest::Test
     assert(num_in_progress==0)
     stop=Time.now
     time_taken=stop-start
-    p "Query count : #{num_sent}, #{timed_out} timed out, #{error_count} other errors. #{time_taken} time taken"
+    puts "Query count : #{num_sent}, #{timed_out} timed out, #{error_count} other errors. #{time_taken} time taken"
     assert(timed_out < num_sent * 0.1, "#{timed_out} of #{num_sent} timed out!")
     assert(error_count == 0)
   end

data/test/tc_tcp.rb

@@ -80,7 +80,7 @@ class TestTcp < Minitest::Test
 
   class HackMessage < Dnsruby::Message
     def wipe_additional
-      @additional = Dnsruby::Message::Section.new(self)
+      @additional = Dnsruby::Section.new(self)
     end
 
     # Decode the encoded message

data/test/tc_tcp_pipelining.rb

@@ -0,0 +1,203 @@
+# --
+# Copyright 2015 Verisign
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require_relative 'spec_helper'
+require_relative 'test_dnsserver'
+
+# The TCPPipeliningServer links our TCPPipeliningHandler on
+# the loopback interface.
+class TCPPipeliningServer < RubyDNS::RuleBasedServer
+
+  PORT = 53937
+  IP   = '127.0.0.1'
+
+  @@stats = Stats.new
+
+  def self.stats
+    @@stats
+  end
+
+  def run
+    fire(:setup)
+
+    link TCPPipeliningHandler.new(self,
+                                  IP,
+                                  PORT,
+                                  TCPPipeliningHandler::DEFAULT_MAX_REQUESTS,
+                                  TCPPipeliningHandler::DEFAULT_TIMEOUT)
+
+    fire(:start)
+  end
+end
+
+class TestTCPPipelining < Minitest::Test
+
+  QUERIES = %w(psi.net  passport.net  verisigninc.com  google.com  yahoo.com  apple.com)
+
+  class << self
+    attr_accessor :query_id
+  end
+
+  def self.init
+    unless @initialized
+      Celluloid.boot
+      # By default, Celluloid logs output to console. Use Dnsruby.log instead
+      Celluloid.logger = Dnsruby.log
+      @initialized = true
+      @query_id = 0
+    end
+  end
+
+  def setup
+    self.class.init
+    @@upstream ||= RubyDNS::Resolver.new([
+        [:udp, '193.0.14.129', 53],
+        [:tcp, '193.0.14.129', 53]])
+
+    # 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,
+        asynchronous: true
+    }
+
+    @@supervisor ||= RubyDNS::run_server(options) do
+      otherwise do |transaction|
+        transaction.passthrough!(@@upstream)
+      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)
+  end
+
+  # Send x number of queries asynchronously to our resolver
+  def send_async_messages(number_of_messages, queue, wait_seconds = 0)
+    query_cycler = QUERIES.cycle
+    number_of_messages.times do
+      message = Dnsruby::Message.new(query_cycler.next)
+      # 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
+
+      # 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
+    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))
+    end
+  end
+
+  # This test initiates multiple asynchronous requests and verifies they go on the same tcp
+  # pipeline or a new one depending on timeouts
+  def test_TCP_pipelining_timeout
+    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)
+
+    # Wait for the timeout to occur (5s) and check timeout_count
+    sleep TCPPipeliningHandler::DEFAULT_TIMEOUT + 0.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)
+
+    assert_equal(accept_count + 2, TCPPipeliningServer.stats.accept_count)
+
+    # Wait for the timeout to occur and check timeout_count
+    sleep TCPPipeliningHandler::DEFAULT_TIMEOUT + 0.5
+
+    assert_equal(timeout_count + 2, TCPPipeliningServer.stats.timeout_count)
+  end
+
+  # Test timeout occurs and new connection is initiated inbetween 2 sends
+  def test_TCP_pipelining_timeout_in_send
+    accept_count  = TCPPipeliningServer.stats.accept_count
+    timeout_count = TCPPipeliningServer.stats.timeout_count
+
+    query_queue = Queue.new
+
+    # Initiate another 3 queries but wait 3s after each query.
+    # Check accept_count. Wait for timeout and verify we got 2 additional timeouts.
+    send_async_messages(3, query_queue, TCPPipeliningHandler::DEFAULT_TIMEOUT / 2.0 + 0.5)
+    verify_responses(3, query_queue)
+
+    assert_equal(accept_count + 2, TCPPipeliningServer.stats.accept_count)
+
+    sleep TCPPipeliningHandler::DEFAULT_TIMEOUT + 0.5
+
+    assert_equal(timeout_count + 2, TCPPipeliningServer.stats.timeout_count)
+  end
+
+  # Test that we get a SocketEofResolvError if the servers closes the socket before
+  # all queries are answered
+  def test_TCP_pipelining_socket_eof
+    accept_count  = TCPPipeliningServer.stats.accept_count
+    timeout_count = TCPPipeliningServer.stats.timeout_count
+    max_count     = TCPPipeliningServer.stats.max_count
+
+    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)
+
+    step = 0
+    6.times do
+      _response_id, response, exception = query_queue.pop
+      if step < TCPPipeliningHandler::DEFAULT_MAX_REQUESTS
+        assert_nil(exception)
+        assert(response.is_a?(Dnsruby::Message))
+      else
+        assert_equal(Dnsruby::SocketEofResolvError, exception.class)
+        assert_nil(response)
+      end
+      step += 1
+    end
+
+    assert_equal(accept_count + 1, TCPPipeliningServer.stats.accept_count)
+    assert_equal(timeout_count,    TCPPipeliningServer.stats.timeout_count)
+    assert_equal(max_count + 1,    TCPPipeliningServer.stats.max_count)
+  end
+end

data/test/tc_zone_reader.rb

@@ -0,0 +1,73 @@
+
+require_relative 'spec_helper'
+
+include Dnsruby
+
+class ZoneReaderTest < Minitest::Test
+
+  def setup
+    @zone_data = <<ZONEDATA
+$TTL 3600
+; Comment
+ ; Comment with whitespace in front
+@                   IN SOA    ns1.example.com. hostmaster.example.com. (
+                                1993112101
+                                10800
+                                3600
+                                604800
+                                7200
+                              )
+                    IN NS     ns1.example.com.
+                    IN NS     ns2.example.com.
+                    IN MX     10 mx.example.com.
+                    IN TXT    "v=spf1 mx ~all"
+www                 IN A      192.0.2.10
+                    IN AAAA   2001:DB8::10
+ftp.example.com.    IN CNAME  www
+db                  IN CNAME  www.example.com.
+ZONEDATA
+
+    @zone_file = Tempfile.new('zonefile')
+    @zone_file << @zone_data
+    @zone_file.flush
+    @zone_file.rewind
+    @reader = Dnsruby::ZoneReader.new("example.com.")
+  end
+
+  def teardown
+    @zone_file.close
+    @zone_file.unlink
+  end
+
+  def check_zone_data_is_valid(zone)
+    assert_equal(1993112101, zone[0].serial)
+    assert_equal("ns1.example.com.", zone[1].rdata)
+    assert_equal("ns2.example.com.", zone[2].rdata)
+    assert_equal("10 mx.example.com.", zone[3].rdata)
+    assert_equal("\"v=spf1 mx ~all\"", zone[4].rdata)
+    assert_equal("192.0.2.10", zone[5].rdata)
+    assert_equal("2001:DB8::10", zone[6].rdata)
+    assert_equal("www.example.com.", zone[7].rdata)
+    assert_equal("www.example.com.", zone[8].rdata)
+  end
+
+  def test_process_file_with_filename
+    zone = @reader.process_file(@zone_file.path)
+    check_zone_data_is_valid(zone)
+  end
+
+  def test_process_file_with_file_object
+    zone = @reader.process_file(@zone_file)
+    check_zone_data_is_valid(zone)
+    assert_equal(false, @zone_file.closed?)
+  end
+
+  def test_process_file_with_stringio_object
+    stringio = StringIO.new(@zone_data)
+    zone = @reader.process_file(stringio)
+    check_zone_data_is_valid(zone)
+    assert_equal(false, stringio.closed?)
+    stringio.close
+  end
+end
+

data/test/test_dnsserver.rb

@@ -0,0 +1,208 @@
+# --
+# Copyright 2015 Verisign
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require 'rubydns'
+require 'nio'
+require 'socket'
+
+# TCPPipeliningHandler accepts new tcp connection and reads data from the sockets until
+# either the client closes the connection, @max_requests_per_connection is reached
+# or @timeout is attained.
+
+class NioTcpPipeliningHandler < RubyDNS::GenericHandler
+
+  DEFAULT_MAX_REQUESTS = 4
+
+  # TODO Add timeout
+  def initialize(server, host, port, max_requests = DEFAULT_MAX_REQUESTS)
+    super(server)
+    @max_requests_per_connection = max_requests
+    @socket = TCPServer.new(host, port)
+    @count = {}
+
+    @selector = NIO::Selector.new
+    monitor = @selector.register(@socket, :r)
+    monitor.value = proc { accept }
+
+    async.run
+  end
+
+  finalizer :finalize
+
+  def finalize
+    @socket.close if @socket
+    @selector.close
+    @selector_thread.join
+  end
+
+  def run
+    @logger.debug "Running selector thread"
+    @selector_thread = create_selector_thread
+  end
+
+  def accept
+    handle_connection(@socket.accept)
+  end
+
+  def process_socket(socket)
+    @logger.debug "Processing socket"
+    _, _remote_port, remote_host = socket.peeraddr
+    options = { peer: remote_host }
+
+    input_data = RubyDNS::StreamTransport.read_chunk(socket)
+    response = process_query(input_data, options)
+    RubyDNS::StreamTransport.write_message(socket, response)
+
+    @count[socket] ||= 0
+    @count[socket]  += 1
+
+    if @count[socket] >= @max_requests_per_connection
+      _, port, host = socket.peeraddr
+      @logger.debug("*** max request for #{host}:#{port}")
+      remove(socket)
+    end
+  rescue EOFError
+    _, port, host = socket.peeraddr
+    @logger.debug("*** #{host}:#{port} disconnected")
+
+    remove(socket)
+  end
+
+  def remove(socket)
+    @logger.debug("Removing socket from selector")
+    socket.close rescue nil
+    @selector.deregister(socket)
+    @count.delete(socket)
+  end
+
+  def create_selector_thread
+    Thread.new do
+      loop do
+        @selector.select { |monitor| monitor.value.call(monitor) }
+        break if @selector.closed?
+      end
+    end
+  end
+
+  def handle_connection(socket)
+    @logger.debug "New connection"
+    @server.class.stats.increment_connection
+
+    @logger.debug "Add socket to @selector"
+    monitor = @selector.register(socket, :r)
+    monitor.value = proc { process_socket(socket) }
+  end
+end
+
+class TCPPipeliningHandler < RubyDNS::GenericHandler
+  DEFAULT_MAX_REQUESTS = 4
+  DEFAULT_TIMEOUT = 3.0
+
+  def initialize(server, host, port, max_requests = DEFAULT_MAX_REQUESTS, timeout = DEFAULT_TIMEOUT)
+    super(server)
+    @timeout = timeout
+    @max_requests_per_connection = max_requests
+    @socket = TCPServer.new(host, port)
+
+    async.run
+  end
+
+  finalizer :finalize
+
+  def finalize
+    @socket.close if @socket
+  end
+
+  def run
+    loop { async.handle_connection(@socket.accept) }
+  end
+
+
+  def handle_connection(socket)
+    _, _remote_port, remote_host = socket.peeraddr
+    options = { peer: remote_host }
+
+    @logger.debug "New connection"
+    @server.class.stats.increment_connection
+
+    timeout = @timeout
+    msg_count = 0
+
+    loop do
+      start_time = Time.now
+      @logger.debug "Waiting for #{timeout} max"
+      sockets = ::IO.select([socket], nil , nil, timeout)
+      duration = Time.now - start_time
+
+      @logger.debug "Slept for #{duration}"
+
+      timeout -= duration
+
+      if sockets
+        input_data = RubyDNS::StreamTransport.read_chunk(socket)
+        response = process_query(input_data, options)
+        RubyDNS::StreamTransport.write_message(socket, response)
+
+        msg_count += 1
+        @logger.debug "Responded to message #{msg_count}"
+      else
+        @logger.debug "TCP session timeout!"
+        @server.class.stats.increment_timeout
+        break
+      end
+
+      if msg_count >= @max_requests_per_connection
+        @logger.debug "Max number of requests attained (#{@max_requests_per_connection})"
+        @server.class.stats.increment_max
+        break
+      end
+
+    end
+  rescue EOFError
+    @logger.warn "TCP session ended (closed by client)"
+  rescue DecodeError
+    @logger.warn "Could not decode incoming TCP data!"
+  ensure
+    socket.close
+  end
+end
+
+# Stats collects statistics from our tcp handler
+class Stats
+  def initialize()
+    @mutex = Mutex.new
+    @accept_count = 0
+    @timeout_count = 0
+    @max_count = 0
+  end
+
+  def increment_max;        @mutex.synchronize { @max_count     += 1 } end
+  def increment_timeout;    @mutex.synchronize { @timeout_count += 1 } end
+  def increment_connection; @mutex.synchronize { @accept_count  += 1 } end
+
+  def accept_count
+    @mutex.synchronize { @accept_count  }
+  end
+
+  def timeout_count
+    @mutex.synchronize { @timeout_count }
+  end
+
+  def max_count
+    @mutex.synchronize { @max_count }
+  end
+
+end