dnsruby 1.57.0 → 1.58.0

data/test/tc_rr-opt.rb

@@ -113,14 +113,15 @@ class TestRrOpt < Minitest::Test
     assert(p.additional()[0].klass.code == 4096)
   end
 
-  def test_large_packet
-    #  Query TXT for overflow.dnsruby.validation-test-servers.nominet.org.uk
-    #  with a large udp_size
-    res = SingleResolver.new
-    res.udp_size = 4096
-    ret = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
-    assert(ret.rcode == RCode.NoError)
-  end
+  # Sadly Nominet no longer host these servers :-(
+  # def test_large_packet
+  #   #  Query TXT for overflow.dnsruby.validation-test-servers.nominet.org.uk
+  #   #  with a large udp_size
+  #   res = SingleResolver.new
+  #   res.udp_size = 4096
+  #   ret = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
+  #   assert(ret.rcode == RCode.NoError)
+  # end
 
   def test_decode_opt
     #  Create an OPT RR

data/test/tc_rr.rb

@@ -328,4 +328,26 @@ class TestRR < Minitest::Test
     assert_equal a1.hash, a2.hash
     assert_equal a1.hash, a3.hash
   end
+
+  def _test_duplicate_answer(method_as_symbol)
+    expected_count = case method_as_symbol
+    when :add_answer
+      1
+    when :add_answer!
+      2
+    end
+
+    rr = RR.new_from_string 'techhumans.com. 1111 IN A 69.89.31.97'
+    message = Message.new
+    2.times { message.send(method_as_symbol, rr) }
+    assert_equal(expected_count, message.header.ancount)
+  end
+
+  def test_add_dup_answer_no_force
+    _test_duplicate_answer(:add_answer)
+  end
+
+  def test_add_dup_answer_force
+    _test_duplicate_answer(:add_answer!)
+  end
 end

data/test/tc_single_resolver.rb

@@ -28,30 +28,30 @@ class TestSingleResolver < Minitest::Test
   Rrs = [
     {
       :type   		=> Types.A,
-      :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :name   		=> 'a.t.net-dns.org',
       :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',
+      :name		=> 'mx.t.net-dns.org',
+      :exchange	=> 'a.t.net-dns.org',
       :preference 	=> 10
     },
     {
       :type		=> 'CNAME',
-      :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
-      :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
+      :name		=> 'cname.t.net-dns.org',
+      :domainname		=> 'a.t.net-dns.org'
     },
     {
       :type		=> Types.TXT,
-      :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :name		=> 'txt.t.net-dns.org',
       :strings		=> ['Net-DNS']
     }
   ]
 
   def test_simple
     res = SingleResolver.new()
-    m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+    m = res.query("ns1.google.com.")
   end
 
   def test_timeout
@@ -69,7 +69,7 @@ class TestSingleResolver < Minitest::Test
       res.port = port
       res.packet_timeout=1
       start_time = Time.now.to_i
-      m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+      m = res.query("a.t.net-dns.org")
       fail "Got response when should have got none"
     rescue ResolvTimeout
       stop_time = Time.now.to_i
@@ -85,7 +85,7 @@ class TestSingleResolver < Minitest::Test
       res.packet_timeout=1
       start_time = Time.now.to_i
 #      TheLog.level = Logger::DEBUG
-      m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+      m = res.query("a.t.net-dns.org")
       fail "TCP timeouts"
     rescue ResolvTimeout
       #         print "Got Timeout for TCP\n"
@@ -112,7 +112,7 @@ class TestSingleResolver < Minitest::Test
       res.port = port
       res.packet_timeout=1
       q = Queue.new
-      msg = Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+      msg = Message.new("a.t.net-dns.org")
       res.send_async(msg, q, msg)
       id,ret, error = q.pop
       assert(id==msg)
@@ -141,7 +141,7 @@ class TestSingleResolver < Minitest::Test
 
       assert(packet, "Got an answer for #{data[:name]} IN #{data[:type]}")
       assert_equal(1, packet.header.qdcount, 'Only one question')
-      assert_equal(1, packet.header.ancount, 'Got single answer')
+      assert_equal(1, packet.header.ancount, "Got single answer (for question #{data[:name]}")
 
       question = (packet.question)[0]
       answer   = (packet.answer)[0]
@@ -184,11 +184,11 @@ class TestSingleResolver < Minitest::Test
   def test_res_config
     res = Dnsruby::SingleResolver.new
 
-    res.server=('a.t.dnsruby.validation-test-servers.nominet.org.uk')
+    res.server=('a.t.net-dns.org')
     ip = res.server
     assert_equal('10.0.1.128', ip.to_s, 'nameserver() looks up IP.')
 
-    res.server=('cname.t.dnsruby.validation-test-servers.nominet.org.uk')
+    res.server=('cname.t.net-dns.org')
     ip = res.server
     assert_equal('10.0.1.128', ip.to_s, 'nameserver() looks up cname.')
   end
@@ -196,9 +196,9 @@ class TestSingleResolver < Minitest::Test
   def test_truncated_response
     res = SingleResolver.new
     #     print "Dnssec = #{res.dnssec}\n"
-    res.server=('ns0.validation-test-servers.nominet.org.uk')
+    # res.server=('ns0.validation-test-servers.nominet.org.uk')
     res.packet_timeout = 15
-    m = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", 'txt')
+    m = res.query("overflow.net-dns.org", 'txt')
     assert(m.header.ancount == 61, "61 answer records expected, got #{m.header.ancount}")
     assert(!m.header.tc, "Message was truncated!")
   end

data/test/tc_soak.rb

@@ -16,24 +16,76 @@
 
 require_relative 'spec_helper'
 
-begin
-require 'test/tc_single_resolver'
-rescue LoadError
-  require 'tc_single_resolver'
-end
-begin
-require 'test/tc_soak_base'
-rescue LoadError
-  require 'tc_soak_base'
-end
+# require_relative 'tc_single_resolver'
+require_relative 'tc_soak_base'
+require_relative 'test_dnsserver'
+
 include Dnsruby
+
 # This class tries to soak test the Dnsruby library.
 # It can't do this very well, owing to the small number of sockets allowed to be open simultaneously.
 # @TODO@ Future versions of dnsruby will allow random streaming over a fixed number of (cycling) random sockets,
 # so this test can be beefed up considerably at that point.
 # @todo@ A test DNS server running on localhost is really needed here
+
+class MyServer < RubyDNS::Server
+
+  IP   = "127.0.0.1"
+  PORT = 53927
+
+  @@stats = Stats.new
+
+  def self.stats
+    @@stats
+  end
+
+  def process(name, resource_class, transaction)
+    transaction.respond!("93.184.216.34", { resource_class: Resolv::DNS::Resource::IN::A })
+    Celluloid.logger.debug "got message"
+  end
+end
+
+class PipeliningServer < MyServer
+  def run
+    fire(:setup)
+
+    link NioTcpPipeliningHandler.new(self, IP, PORT, 5) #5 max request
+    link RubyDNS::UDPHandler.new(self, IP, PORT)
+
+    fire(:start)
+  end
+end
+
 class TestSingleResolverSoak < Minitest::Test
 
+  IP   = MyServer::IP
+  PORT = MyServer::PORT
+
+  def initialize(arg)
+    super(arg)
+    self.class.init
+  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
+    end
+  end
+
+  SINGLE_RESOLVER_QUERY_TIMES = 63
+
+  def setup
+    # Instantiate a new server
+    # For each query respond with 93.184.216.34
+
+    @@supervisor ||= RubyDNS::run_server(asynchronous: true,
+                                         server_class: PipeliningServer)
+
+  end
+
   def test_many_asynchronous_queries_one_single_resolver
     run_many_asynch_queries_test_single_res(1)
   end
@@ -42,58 +94,87 @@ class TestSingleResolverSoak < Minitest::Test
     run_many_asynch_queries_test_single_res(50)
   end
 
-  def run_many_asynch_queries_test_single_res(num_resolvers)
+  def test_many_asynchronous_queries_one_single_resolver_tcp
+    run_many_asynch_queries_test_single_res(1, true)
+  end
+
+  def test_many_asynchronous_queries_many_single_resolvers_tcp
+    run_many_asynch_queries_test_single_res(50, true)
+  end
+
+  def test_many_asynchronous_queries_one_single_resolver_tcp_pipelining
+    run_many_asynch_queries_test_single_res(1, true, true)
+  end
+
+  def test_many_asynchronous_queries_many_single_resolvers_tcp_pipelining
+    run_many_asynch_queries_test_single_res(50, true, true)
+  end
+
+  def run_many_asynch_queries_test_single_res(num_resolvers, tcp = false, pipelining = false)
     q = Queue.new
-    resolvers = []
-    timed_out = 0
-    query_count = 0
-    num_resolvers.times do |n|
-      resolvers.push(SingleResolver.new)
-      resolvers[n].packet_timeout=4
+    timeout_count = 0
+    resolvers = Array.new(num_resolvers) do
+      SingleResolver.new(server:                     IP,
+                         port:                       PORT,
+                         do_caching:                 false,
+                         do_validation:              false,
+                         tcp_pipelining:             pipelining,
+                         packet_timeout:             10,
+                         tcp_pipelining_max_queries: 5,
+                         use_tcp:                    tcp)
     end
-    res_pos = 0
     start = Time.now
+
     #  @todo@ On windows, MAX_FILES is 256. This means that we have to limit
     #  this test while we're not using single sockets.
     #  We run four queries per iteration, so we're limited to 64 runs.
-    63.times do |i|
-      rr_count = 0
-      TestSoakBase::Rrs.each do |data|
-        rr_count+=1
-        res = resolvers[res_pos]
-        res_pos=+1
-        if (res_pos >= num_resolvers)
-          res_pos = 0
+    messages = TestSoakBase::Rrs.map do |data|
+      message = Message.new(data[:name], data[:type])
+      message.do_validation = false
+      message.do_caching    = false
+      message
+    end
+
+    query_count = SINGLE_RESOLVER_QUERY_TIMES * messages.count
+
+    receive_thread = Thread.new do
+      query_count.times do
+        _id, ret, error = q.pop
+        if error.is_a?(ResolvTimeout)
+          timeout_count+=1
+        elsif ret.class != Message
+          p "ERROR RETURNED : #{error}"
         end
-        res.send_async(Message.new(data[:name], data[:type]), q, [i,rr_count])
-        #         p "Sent #{i}, #{rr_count}, Queue #{q}"
-        query_count+=1
       end
     end
-    query_count.times do |i|
-      id,ret, error = q.pop
-      if (error.class == ResolvTimeout)
-        timed_out+=1
-      elsif (ret.class != Message)
-        p "ERROR RETURNED : #{error}"
-      end
 
+    resolver_cycler = resolvers.cycle
+
+    SINGLE_RESOLVER_QUERY_TIMES.times do |i|
+      rr_count = 0
+      messages.each do | message |
+        rr_count += 1
+        resolver_cycler.next.send_async(message, q, rr_count + i * messages.count)
+        #         p "Sent #{i}, #{rr_count}, Queue #{q}"
+      end
     end
-    stop=Time.now
-    time_taken=stop-start
-    p "Query count : #{query_count}, #{timed_out} timed out. #{time_taken} time taken"
-    assert(timed_out < query_count * 0.1, "#{timed_out} of #{query_count} timed out!")
-  end
 
+    receive_thread.join
+
+    time_taken = Time.now - start
+    puts "Query count : #{query_count}, #{timeout_count} timed out. #{time_taken} time taken"
+    assert(timeout_count < query_count * 0.1, "#{timeout_count} of #{query_count} timed out!")
+  end
 
   def test_many_threads_on_one_single_resolver_synchronous
     #  Test multi-threaded behaviour
     #  Check the header IDs to make sure they're all different
     threads = Array.new
-    res = SingleResolver.new
+
+    res = create_default_single_resolver
     ids = []
     mutex = Mutex.new
-    timed_out = 0
+    timeout_count = 0
     query_count = 0
     res.packet_timeout=4
     start=Time.now
@@ -107,16 +188,12 @@ class TestSingleResolverSoak < Minitest::Test
       threads[i] = Thread.new{
         40.times do |j|
           TestSoakBase::Rrs.each do |data|
-            mutex.synchronize do
-              query_count+=1
-            end
+            mutex.synchronize { query_count += 1 }
             packet=nil
             begin
               packet = res.query(data[:name], data[:type])
             rescue ResolvTimeout
-              mutex.synchronize {
-                timed_out+=1
-              }
+              mutex.synchronize { timeout_count += 1 }
               next
             end
             assert(packet)
@@ -131,9 +208,9 @@ class TestSingleResolverSoak < Minitest::Test
     end
     stop=Time.now
     time_taken=stop-start
-    p "Query count : #{query_count}, #{timed_out} timed out. #{time_taken} time taken"
+    puts "Query count : #{query_count}, #{timeout_count} timed out. #{time_taken} time taken"
     #     check_ids(ids) # only do this if we expect all different IDs - e.g. if we stream over a single socket
-    assert(timed_out < query_count * 0.1, "#{timed_out} of #{query_count} timed out!")
+    assert(timeout_count < query_count * 0.1, "#{timeout_count} of #{query_count} timed out!")
   end
 
   def check_ids(ids)
@@ -152,7 +229,7 @@ class TestSingleResolverSoak < Minitest::Test
     #  @todo@ Check the header IDs to make sure they're all different
     threads = Array.new
     mutex = Mutex.new
-    timed_out = 0
+    timeout_count = 0
     query_count = 0
     start=Time.now
     num_times=250
@@ -162,23 +239,28 @@ class TestSingleResolverSoak < Minitest::Test
     end
     num_times.times do |i|
       threads[i] = Thread.new{
-        res = SingleResolver.new
-        res.packet_timeout=4
+        res = create_default_single_resolver
         40.times do |j|
           TestSoakBase::Rrs.each do |data|
             mutex.synchronize do
               query_count+=1
             end
             q = Queue.new
-            res.send_async(Message.new(data[:name], data[:type]), q, [i,j])
+
+            message = Message.new(data[:name], data[:type])
+            message.do_validation = false
+            message.do_caching    = false
+
+            res.send_async(message, q, [i,j])
+
             id, packet, error = q.pop
             if (error.class == ResolvTimeout)
               mutex.synchronize {
-                timed_out+=1
+                timeout_count+=1
               }
               next
             elsif (packet.class!=Message)
-              p "ERROR! #{error}"
+              puts "ERROR! #{error}"
             end
 
             assert(packet)
@@ -187,14 +269,21 @@ class TestSingleResolverSoak < Minitest::Test
         end
       }
     end
-    threads.each do |thread|
-      thread.join
-    end
-    stop=Time.now
-    time_taken=stop-start
-    p "Query count : #{query_count}, #{timed_out} timed out. #{time_taken} time taken"
-    assert(timed_out < query_count * 0.1, "#{timed_out} of #{query_count} timed out!")
+    # NOTE: For methods on the objects taking no params, we can use this shorthand.
+    threads.each(&:join)
+
+    time_taken = Time.now - start
+    puts "Query count : #{query_count}, #{timeout_count} timed out. #{time_taken} time taken"
+    assert(timeout_count < query_count * 0.1, "#{timeout_count} of #{query_count} timed out!")
   end
 
 
-end
+  def create_default_single_resolver
+    SingleResolver.new(server:         IP,
+                       port:           PORT,
+                       do_caching:     false,
+                       do_validation:  false,
+                       packet_timeout: 10)
+
+  end
+end