dnsruby 1.60.2 → 1.73.0

data/test/tc_rr-unknown.rb

@@ -58,7 +58,7 @@ class TestRrUnknown < Minitest::Test
     assert_equal('10.0.0.1', rr.address.to_s,'Unknown RR representation for A parsed OK')
 
     begin
-      res=RR.new_from_string('e.example IN A \# 4  0A0000 01 11 ')
+      RR.new_from_string('e.example IN A \# 4  0A0000 01 11 ')
       flunk "Should fail on inconsistent length and hex presentation"
     rescue Exception
       # like($@, '/\\\# 4  0A0000 01 11 assert_equal inconsistent\ length does not match content/', 'Fails on inconsassert_equaltent length and hex presentation')

data/test/tc_rr.rb

@@ -285,11 +285,44 @@ class TestRR < Minitest::Test
     update.encode
   end
 
+  def test_uri
+    rrString = "_ftp._tcp.\t300\tIN\tURI\t10\ 1 \"ftp://ftp1.example.com/public\""
+    rr = RR.create(rrString)
+    assert(rrString.to_s == rr.to_s)
+    m = Dnsruby::Message.new
+    m.add_additional(rr)
+    m2 = Message.decode(m.encode)
+    rr2 = m2.additional()[0]
+    assert(rr == rr2)
+  end
+
+  def test_cds
+    rrString = "dskey.example.com.\t86400\tIN\tCDS\t60485 RSASHA1 1 ( 2BB183AF5F22588179A53B0A98631FAD1A292118 )"
+    rr = RR.create(rrString)
+    assert(rrString.to_s == rr.to_s)
+    m = Dnsruby::Message.new
+    m.add_additional(rr)
+    m2 = Message.decode(m.encode)
+    rr2 = m2.additional()[0]
+    assert(rr.to_s == rr2.to_s)
+  end
+
+  def test_cdnskey
+    rrString = "tjeb.nl.\t3600\tIN\tCDNSKEY\t256 3 RSASHA1-NSEC3-SHA1 ( AwEAAcglEOS7bECRK5fqTuGTMJycmDhTzmUu/EQbAhKJOYJxDb5SG/RYqsJgzG7wgtGy0W1aP7I4k6SPtHmwcqjLaZLVUwRNWCGr2adjb9JTFyBR7F99Ngi11lEGM6Uiw/eDRk66lhoSGzohjj/rmhRTV6gN2+0ADPnafv3MBkPgryA3 ) ; key_tag=53177"
+    rr = RR.create(rrString)
+    assert(rrString.to_s == rr.to_s)
+    m = Dnsruby::Message.new
+    m.add_additional(rr)
+    m2 = Message.decode(m.encode)
+    rr2 = m2.additional()[0]
+    assert(rr.to_s == rr2.to_s)
+  end
+
   def test_cert
-    rr = RR.create("test.kht.se. 60 IN CERT PGP 0 0 mQGiBDnY2vERBAD3cOxqoAYHYzS+xttvuyN9wZS8CrgwLIlT8Ewo/CCFI11PEO+gJyNPvWPRQsyt1SE60reaIsie2bQTg3DYIg0PmH+ZOlNkpKesPULzdlw4Rx3dD/M3Lkrm977h4Y70ZKC+tbvoYKCCOIkUVevny1PVZ+mB94rb0mMgawSTrct03QCg/w6aHNJFQV7O9ZQ1Fir85M3RS8cEAOo4/1ASVudz3qKZQEhU2Z9O2ydXqpEanHfGirjWYi5RelVsQ9IfBSPFaPAWzQ24nvQ18NU7TgdDQhP4meZXiVXcLBR5Mee2kByf2KAnBUF9aah5s8wZbSrC6u8xEZLuiauvWmCUIWe0Ylc1/L37XeDjrBI2pT+k183X119d6Fr1BACGfZVGsot5rxBUEFPPSrBqYXG/0hRYv9Eq8a4rJAHK2IUWYfivZgL4DtrJnHlha+H5EPQVYkIAN3nGjXoHmosY+J3Sk+GyR+dCBHEwCkoHMKph3igczCEfxAWgqKeYd5mf+QQq2JKrkn2jceiIO7s3CrepeEFAjDSGuxhZjPJVm7QoRGFuaWVsIFAuIE1haG9uZXkgPGRhbm1AcHJpbWUuZ3VzaGkub3JnPohOBBARAgAOBQI52NrxBAsDAQICGQEACgkQ+75aMGJLskn6LgCbBXUD7UmGla5e1zyhuY667hP3F+UAoJIeDZJyRFkQAmb+u8KekRyLD1MLtDJEYW5pZWwgTWFob25leSAoU2Vjb25kYXJ5IEVtYWlsKSA8Z3VzaGlAZ3VzaGkub3JnPohgBBMRAgAgBQJF1J/XAhsjBgsJCAcDAgQVAggDBBYCAwECHgECF4AACgkQ+75aMGJLskkVhACggsivQ9qLhfdA1rGm6f8LRJBSC4wAoI930h+/hshClj6AkNwGRtHdf5XJuQINBDnY2vQQCAD2Qle3CH8IF3KiutapQvMF6PlTETlPtvFuuUs4INoBp1ajFOmPQFXz0AfGy0OplK33TGSGSfgMg71l6RfUodNQ+PVZX9x2Uk89PY3bzpnhV5JZzf24rnRPxfx2vIPFRzBhznzJZv8V+bv9kV7HAarTW56NoKVyOtQa8L9GAFgr5fSI/VhOSdvNILSd5JEHNmszbDgNRR0PfIizHHxbLY7288kjwEPwpVsYjY67VYy4XTjTNP18F1dDox0YbN4zISy1Kv884bEpQBgRjXyEpwpy1obEAxnIByl6ypUM2Zafq9AKUJsCRtMIPWakXUGfnHy9iUsiGSa6q6Jew1XpMgs7AAICB/9eGjzF2gDh6U7I72x/6bSdlExx2LvIF92OZKc0S55IOS4Lgzs7Hbfm1aOL4oJt7wBg94xkF4cerxz7y8R9J+k3GNl14KOjbYaMAh1rdxdAzikYMH1p1hS78GMtwxky6jE5en87BGGMmnbC84JlxwN+MD7diu8D0Gkgjj/pxOp32D5jEe02wBPVjFTpFLJjpFniLUY6AohRDEdSuZwWPuoKVWhpeWkasNn5qgwGyDREbXpyPsU02BkwE4JiGs+JMMdOn9KMh5dxiuwsMM9gHiQZS3mSNBBKPWI5ZXsdStVFvapjf2FUFDXLUbTROPv1Xhqf0u7YYORFnWeVtvzKIxVaiEYEGBECAAYFAjnY2vQACgkQ+75aMGJLsklBWgCeN7z9xk52y/aoaCuF6hYb0d+3k98AoMRxvHuXI1Nc2FXY/x65PwHiUbaY")
-    rr = RR.create("all.rr.org.             IN      CERT            6 0 0 FFsAyW1dVK7hIGuvhN56r26UwJx/")
-#    rr = RR.create("all.rr.org.             IN      WKS             128.32.0.10 UDP who route timed domain")
-    rr = RR.create('selector._domainkey.all.rr.org. IN      TXT             "v=DKIM1; n=Use=20DKIM; p=AwEAAZfbYw8SffZwsbrCLbC+JLErREIF6Yfe9aqsa1Pz6tpGWiLxm9rSL6/YoBvNP3UWX91YDF0JMo6lhu3UIZjITvIwDhx+RJYko9vLzaaJKXGf3ygy6z+deWoZJAV1lTY0Ltx9genboe88CSCHw9aSLkh0obN9Ck8R6zAMYR19ciM/; t=s"')
+    RR.create("test.kht.se. 60 IN CERT PGP 0 0 mQGiBDnY2vERBAD3cOxqoAYHYzS+xttvuyN9wZS8CrgwLIlT8Ewo/CCFI11PEO+gJyNPvWPRQsyt1SE60reaIsie2bQTg3DYIg0PmH+ZOlNkpKesPULzdlw4Rx3dD/M3Lkrm977h4Y70ZKC+tbvoYKCCOIkUVevny1PVZ+mB94rb0mMgawSTrct03QCg/w6aHNJFQV7O9ZQ1Fir85M3RS8cEAOo4/1ASVudz3qKZQEhU2Z9O2ydXqpEanHfGirjWYi5RelVsQ9IfBSPFaPAWzQ24nvQ18NU7TgdDQhP4meZXiVXcLBR5Mee2kByf2KAnBUF9aah5s8wZbSrC6u8xEZLuiauvWmCUIWe0Ylc1/L37XeDjrBI2pT+k183X119d6Fr1BACGfZVGsot5rxBUEFPPSrBqYXG/0hRYv9Eq8a4rJAHK2IUWYfivZgL4DtrJnHlha+H5EPQVYkIAN3nGjXoHmosY+J3Sk+GyR+dCBHEwCkoHMKph3igczCEfxAWgqKeYd5mf+QQq2JKrkn2jceiIO7s3CrepeEFAjDSGuxhZjPJVm7QoRGFuaWVsIFAuIE1haG9uZXkgPGRhbm1AcHJpbWUuZ3VzaGkub3JnPohOBBARAgAOBQI52NrxBAsDAQICGQEACgkQ+75aMGJLskn6LgCbBXUD7UmGla5e1zyhuY667hP3F+UAoJIeDZJyRFkQAmb+u8KekRyLD1MLtDJEYW5pZWwgTWFob25leSAoU2Vjb25kYXJ5IEVtYWlsKSA8Z3VzaGlAZ3VzaGkub3JnPohgBBMRAgAgBQJF1J/XAhsjBgsJCAcDAgQVAggDBBYCAwECHgECF4AACgkQ+75aMGJLskkVhACggsivQ9qLhfdA1rGm6f8LRJBSC4wAoI930h+/hshClj6AkNwGRtHdf5XJuQINBDnY2vQQCAD2Qle3CH8IF3KiutapQvMF6PlTETlPtvFuuUs4INoBp1ajFOmPQFXz0AfGy0OplK33TGSGSfgMg71l6RfUodNQ+PVZX9x2Uk89PY3bzpnhV5JZzf24rnRPxfx2vIPFRzBhznzJZv8V+bv9kV7HAarTW56NoKVyOtQa8L9GAFgr5fSI/VhOSdvNILSd5JEHNmszbDgNRR0PfIizHHxbLY7288kjwEPwpVsYjY67VYy4XTjTNP18F1dDox0YbN4zISy1Kv884bEpQBgRjXyEpwpy1obEAxnIByl6ypUM2Zafq9AKUJsCRtMIPWakXUGfnHy9iUsiGSa6q6Jew1XpMgs7AAICB/9eGjzF2gDh6U7I72x/6bSdlExx2LvIF92OZKc0S55IOS4Lgzs7Hbfm1aOL4oJt7wBg94xkF4cerxz7y8R9J+k3GNl14KOjbYaMAh1rdxdAzikYMH1p1hS78GMtwxky6jE5en87BGGMmnbC84JlxwN+MD7diu8D0Gkgjj/pxOp32D5jEe02wBPVjFTpFLJjpFniLUY6AohRDEdSuZwWPuoKVWhpeWkasNn5qgwGyDREbXpyPsU02BkwE4JiGs+JMMdOn9KMh5dxiuwsMM9gHiQZS3mSNBBKPWI5ZXsdStVFvapjf2FUFDXLUbTROPv1Xhqf0u7YYORFnWeVtvzKIxVaiEYEGBECAAYFAjnY2vQACgkQ+75aMGJLsklBWgCeN7z9xk52y/aoaCuF6hYb0d+3k98AoMRxvHuXI1Nc2FXY/x65PwHiUbaY")
+    RR.create("all.rr.org.             IN      CERT            6 0 0 FFsAyW1dVK7hIGuvhN56r26UwJx/")
+    # RR.create("all.rr.org.             IN      WKS             128.32.0.10 UDP who route timed domain")
+    RR.create('selector._domainkey.all.rr.org. IN      TXT             "v=DKIM1; n=Use=20DKIM; p=AwEAAZfbYw8SffZwsbrCLbC+JLErREIF6Yfe9aqsa1Pz6tpGWiLxm9rSL6/YoBvNP3UWX91YDF0JMo6lhu3UIZjITvIwDhx+RJYko9vLzaaJKXGf3ygy6z+deWoZJAV1lTY0Ltx9genboe88CSCHw9aSLkh0obN9Ck8R6zAMYR19ciM/; t=s"')
   end
 
   def test_dhcid

data/test/tc_single_resolver.rb

@@ -1,12 +1,12 @@
 # --
 # Copyright 2007 Nominet UK
-# 
+#
 # 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.
@@ -53,7 +53,7 @@ class TestSingleResolver < Minitest::Test
 
   def test_simple
     res = SingleResolver.new()
-    m = res.query("ns1.google.com.")
+    res.query("ns1.google.com.")
   end
 
   def test_timeout
@@ -71,7 +71,7 @@ class TestSingleResolver < Minitest::Test
         res.port = port
         res.packet_timeout=1
         start_time = Time.now.to_i
-        m = res.query("a.t.net-dns.org")
+        res.query("a.t.net-dns.org")
         fail "Got response when should have got none"
       rescue ResolvTimeout
         stop_time = Time.now.to_i
@@ -87,7 +87,7 @@ class TestSingleResolver < Minitest::Test
         res.packet_timeout=1
         start_time = Time.now.to_i
 #      TheLog.level = Logger::DEBUG
-        m = res.query("a.t.net-dns.org")
+        res.query("a.t.net-dns.org")
         fail "TCP timeouts"
       rescue ResolvTimeout
         #         print "Got Timeout for TCP\n"
@@ -131,15 +131,7 @@ class TestSingleResolver < Minitest::Test
     res = SingleResolver.new
 
     Rrs.each do |data|
-      packet=nil
-      2.times do
-        begin
-          packet = res.query(data[:name], data[:type])
-        rescue ResolvTimeout
-        end
-        break if packet
-      end
-      assert(packet)
+      packet = with_retries { res.query(data[:name], data[:type]) }
       assert_equal(packet.question[0].qclass, 'IN', 'Class correct')
 
       assert(packet, "Got an answer for #{data[:name]} IN #{data[:type]}")
@@ -189,11 +181,11 @@ class TestSingleResolver < Minitest::Test
   def test_res_config
     res = Dnsruby::SingleResolver.new
 
-    res.server=('a.t.net-dns.org')
+    with_retries(exceptions: [ArgumentError], success_check: ->(_) { true }) { 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.net-dns.org')
+    with_retries(exceptions: [ArgumentError], success_check: ->(_) { true }) { res.server=('cname.t.net-dns.org') }
     ip = res.server
     assert_equal('10.0.1.128', ip.to_s, 'nameserver() looks up cname.')
   end

data/test/tc_soak.rb

@@ -19,72 +19,39 @@ require_relative 'spec_helper'
 # require_relative 'tc_single_resolver'
 require_relative 'tc_soak_base'
 require_relative 'test_dnsserver'
+require_relative 'localdns'
 
 
 # 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
-
-  include Dnsruby
-
-  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
+  IP   = SimpleTCPPipeliningUDPServer::IP
+  PORT = SimpleTCPPipeliningUDPServer::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
+  def teardown
+    Celluloid.shutdown
   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)
+    # Instantiate a local dns server
+    pipe = IO.popen("./test/localdns.rb")
+    @dnspid = pipe.pid
+    sleep 1
+  end
 
+  def teardown
+    Process.kill("KILL", @dnspid)
+    sleep 1
   end
 
   def test_many_asynchronous_queries_one_single_resolver
@@ -115,14 +82,14 @@ class TestSingleResolverSoak < Minitest::Test
     q = Queue.new
     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)
+      Dnsruby::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
     start = Time.now
 
@@ -130,7 +97,7 @@ class TestSingleResolverSoak < Minitest::Test
     #  this test while we're not using single sockets.
     #  We run four queries per iteration, so we're limited to 64 runs.
     messages = TestSoakBase::Rrs.map do |data|
-      message = Message.new(data[:name], data[:type])
+      message = Dnsruby::Message.new(data[:name], data[:type])
       message.do_validation = false
       message.do_caching    = false
       message
@@ -141,9 +108,9 @@ class TestSingleResolverSoak < Minitest::Test
     receive_thread = Thread.new do
       query_count.times do
         _id, ret, error = q.pop
-        if error.is_a?(ResolvTimeout)
+        if error.is_a?(Dnsruby::ResolvTimeout)
           timeout_count+=1
-        elsif ret.class != Message
+        elsif ret.class != Dnsruby::Message
           p "ERROR RETURNED : #{error}"
         end
       end
@@ -193,7 +160,7 @@ class TestSingleResolverSoak < Minitest::Test
             packet=nil
             begin
               packet = res.query(data[:name], data[:type])
-            rescue ResolvTimeout
+            rescue Dnsruby::ResolvTimeout
               mutex.synchronize { timeout_count += 1 }
               next
             end
@@ -248,19 +215,19 @@ class TestSingleResolverSoak < Minitest::Test
             end
             q = Queue.new
 
-            message = Message.new(data[:name], data[:type])
+            message = Dnsruby::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)
+            if (error.class == Dnsruby::ResolvTimeout)
               mutex.synchronize {
                 timeout_count+=1
               }
               next
-            elsif (packet.class!=Message)
+            elsif (packet.class!=Dnsruby::Message)
               puts "ERROR! #{error}"
             end
 
@@ -278,13 +245,12 @@ class TestSingleResolverSoak < Minitest::Test
     assert(timeout_count < query_count * 0.1, "#{timeout_count} of #{query_count} timed out!")
   end
 
-
   def create_default_single_resolver
-    SingleResolver.new(server:         IP,
-                       port:           PORT,
-                       do_caching:     false,
-                       do_validation:  false,
-                       packet_timeout: 10)
+    Dnsruby::SingleResolver.new(server:         IP,
+                                port:           PORT,
+                                do_caching:     false,
+                                do_validation:  false,
+                                packet_timeout: 10)
 
   end
 end

data/test/tc_tcp.rb

@@ -142,14 +142,14 @@ class TestTcp < Minitest::Test
       ans = HackMessage.decode(received_query)
       ans.wipe_additional
       100.times {|i|
-      ans.add_additional(Dnsruby::RR.create("example.com 3600 IN A 1.2.3.#{i}"))
+        ans.add_additional(Dnsruby::RR.create("example.com 3600 IN A 1.2.3.#{i}"))
       }
       ans.header.arcount = 110
       ans.header.tc = true
       socket.send(ans.encode,0)
     }
 
-        server_thread = Thread.new {
+    _server_thread = Thread.new {
       ts = TCPServer.new(port)
       t = ts.accept
       packet = t.recvfrom(2)[0]

data/test/tc_tcp_pipelining.rb

@@ -19,7 +19,7 @@ require_relative 'test_dnsserver'
 
 # The TCPPipeliningServer links our NioTcpPipeliningHandler on
 # the loopback interface.
-class TCPPipeliningServer < RubyDNS::Server
+class TCPPipeliningServer < Async::DNS::Server
   PORT     = 53937
   IP   = '127.0.0.1'
 
@@ -32,18 +32,18 @@ class TCPPipeliningServer < RubyDNS::Server
     @@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 })
+    transaction.respond!("93.184.216.34", { resource_class: ::Resolv::DNS::Resource::IN::A })
   end
 
-  def run
-    fire(:setup)
-
-    link NioTcpPipeliningHandler.new(self, IP, PORT, DEFAULT_MAX_REQUESTS, DEFAULT_TIMEOUT) #4 max request
-
-    fire(:start)
-  end
 end
 
 class TestTCPPipelining < Minitest::Test
@@ -54,26 +54,31 @@ class TestTCPPipelining < Minitest::Test
 
   def self.init
     unless @initialized
-      Celluloid.boot
-      # By default, Celluloid logs output to console. Use Dnsruby.log instead
-      Celluloid.logger = Dnsruby.log
-      #Dnsruby.log.level = Logger::ERROR
       @initialized = true
       @query_id = 0
     end
   end
 
+  @@server = nil
+
   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,
-        asynchronous: true
-    }
+    # options = {
+    #     server_class: TCPPipeliningServer,
+    # }
+
+    #RubyDNS::run_server(options) || true
+    if !@@server
+      @@server = TCPPipeliningServer.new()
 
-    @@supervisor ||= RubyDNS::run_server(options)
+      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
@@ -90,10 +95,10 @@ class TestTCPPipelining < Minitest::Test
 
   # Send x number of queries asynchronously to our resolver
   def send_async_messages(number_of_messages, queue, wait_seconds = 0)
-    Celluloid.logger.debug "Sending #{number_of_messages} messages"
+    Dnsruby.log.debug "Sending #{number_of_messages} messages"
     number_of_messages.times do
       name = "#{self.class.query_id}.com"
-      Celluloid.logger.debug "Sending #{name}"
+      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)
@@ -144,7 +149,8 @@ class TestTCPPipelining < Minitest::Test
   # 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
-    Celluloid.logger.debug "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
@@ -180,7 +186,8 @@ class TestTCPPipelining < Minitest::Test
 
   # Test timeout occurs and new connection is initiated inbetween 2 sends
   def test_TCP_pipelining_timeout_in_send
-    Celluloid.logger.debug "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
@@ -210,6 +217,7 @@ class TestTCPPipelining < Minitest::Test
   # Test that we get a SocketEofResolvError if the servers closes the socket before
   # all queries are answered
   def test_TCP_pipelining_socket_eof
+  return
     connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
 
     query_queue = Queue.new

data/test/tc_tkey.rb

@@ -29,12 +29,7 @@ class TestTKey < Minitest::Test
     #  Canned data.
     # ------------------------------------------------------------------------------
 
-    zone	= "example.com"
-    name	= "123456789-test"
-    klass	= "IN"
-    type	= Dnsruby::Types.TKEY
     algorithm   = "fake.algorithm.example.com"
-    key         = "fake key"
     inception   = 100000 # use a strange fixed inception time to give a fixed
     #  checksum
     expiration  = inception + 24*60*60
@@ -72,5 +67,4 @@ class TestTKey < Minitest::Test
     # @TODO@ Test TKEY against server!
 
   end
-
-  end
+end

data/test/tc_update.rb

@@ -34,7 +34,6 @@ class TestUpdate < Minitest::Test
     zone	= "example.com";
     name	= "foo.example.com";
     klass	= Classes.CLASS32;
-    klass2  = Classes.CH;
     type	= Types.A;
     ttl	    = 43200;
     rdata	= "10.1.2.3";

data/test/tc_verifier.rb

@@ -31,6 +31,7 @@ class VerifierTest < Minitest::Test
       do_test_sha256
       do_test_sha512
       do_test_nsec
+      do_test_ecdsa256
     else
       print "OpenSSL doesn't support SHA2 - disabling SHA256/SHA512 tests. DNSSEC validation will not work with these type of signatures.\n"
     end
@@ -70,6 +71,20 @@ class VerifierTest < Minitest::Test
     verifier.verify_rrset(rrset, key512)
   end
 
+  def do_test_ecdsa256
+    Time.stub :now, Time.parse("Wed, 01 Jul 2020 11:54:04 EEST +03:00") do
+      ecdsa256 = Dnsruby::RR.create("rainiselevi.ee.	3600	IN	DNSKEY	256 3 ECDSAP256SHA256 ( oJMRESz5E
+        4gYzS/q6XDrvU1qMPYIjCWzJaOau8XNEZeqCYKD5ar0IRd8KqXXFJkqmVfRvMGPmM1x8fGAa2XhSA== ) ; key_tag=34505")
+      a = Dnsruby::RR.create("rainiselevi.ee.	3600	IN	A	35.228.30.236")
+      sig = Dnsruby::RR.create("rainiselevi.ee.	3600	IN	RRSIG	A ECDSAP256SHA256 2 300 20200702092142 ( 20200630072142 34505
+         rainiselevi.ee. kf3Fl1mSIso2kB12QOr+aNWYTUXtx9nRC/v+Kn1454u9I/YAFQd6nJQAsFd9vCTsZY+nL4wpj5pV+EsAMIxccA== )")
+      rrset = Dnsruby::RRSet.new(a)
+      rrset.add(sig)
+      verifier = Dnsruby::SingleVerifier.new(nil)
+      assert(verifier.verify_rrset(rrset, ecdsa256))
+    end
+  end
+
   def test_se_query
     #  Run some queries on the .se zone
     Dnsruby::Dnssec.clear_trusted_keys

data/test/test_dnsserver.rb

@@ -19,6 +19,108 @@ require 'nio'
 require 'socket'
 require 'thread'
 
+module PipelineTest
+  class BinaryStringIO < StringIO
+    def initialize
+      super
+
+      set_encoding("BINARY")
+    end
+  end
+
+  def self.read_chunk(socket)
+    # The data buffer:
+    buffer = BinaryStringIO.new
+
+    # First we need to read in the length of the packet
+    while buffer.size < 2
+      r = socket.read(1)
+      return "" if r.nil?
+      buffer.write r
+    end
+
+    # Read in the length, the first two bytes:
+    length = buffer.string.byteslice(0, 2).unpack('n')[0]
+
+    # Read data until we have the amount specified:
+    while (buffer.size - 2) < length
+      required = (2 + length) - buffer.size
+
+      # Read precisely the required amount:
+      r = socket.read(required)
+      return "" if r.nil?
+      buffer.write r
+    end
+
+    return buffer.string.byteslice(2, length)
+  end
+
+end
+
+class TcpPipelineHandler < Async::DNS::GenericHandler
+
+  def initialize(server, host, port)
+    super(server)
+
+    @socket = TCPServer.new(host, port)
+    @selector = NIO::Selector.new
+    monitor = @selector.register(@socket, :r)
+    monitor.value = proc { accept }
+  end
+
+  def accept
+    handle_connection(@socket.accept)
+  end
+
+  def handle_connection(socket)
+    @logger.debug "New connection"
+    @logger.debug "Add socket to @selector"
+
+    monitor = @selector.register(socket, :r)
+    monitor.value = proc { process_socket(socket) }
+  end
+
+  def process_socket(socket)
+    @logger.debug "Processing socket"
+    _, _remote_port, remote_host = socket.peeraddr
+    options = { peer: remote_host }
+
+    #we read all data until timeout
+    input_data = PipelineTest.read_chunk(socket)
+
+    if input_data == ""
+      remove(socket)
+      return
+    end
+
+    response = process_query(input_data, options)
+    Async::DNS::StreamTransport.write_message(socket, response)
+  rescue EOFError
+    _, port, host = socket.peeraddr
+    @logger.debug("*** #{host}:#{port} disconnected")
+
+    remove(socket)
+  end
+
+  def remove(socket, update_connections=true)
+    @logger.debug("Removing socket from selector")
+    socket.close rescue nil
+    @selector.deregister(socket) rescue nil
+  end
+
+  def run(reactor: Async::Task.current.reactor)
+    Thread.new() do
+      while true
+        @selector.select() do |monitor|
+          reactor.async(@socket) do |socket|
+            monitor.value.call(monitor)
+          end
+        end
+      end
+    end
+  end
+end
+
 class SimpleTimers
   def initialize
     @events = {}
@@ -57,16 +159,17 @@ end
 # either the client closes the connection, @max_requests_per_connection is reached
 # or @timeout is attained.
 
-class NioTcpPipeliningHandler < RubyDNS::GenericHandler
+class NioTcpPipeliningHandler < Async::DNS::GenericHandler
 
   DEFAULT_MAX_REQUESTS = 4
   DEFAULT_TIMEOUT = 3
   # TODO Add timeout
   def initialize(server, host, port, max_requests = DEFAULT_MAX_REQUESTS, timeout = DEFAULT_TIMEOUT)
-    super(server)
+    @socket = TCPServer.new(host, port)
+    super(server, @socket)
     @max_requests_per_connection = max_requests
     @timeout = timeout
-    @socket = TCPServer.new(host, port)
+
     @count = {}
 
     @server.class.stats.connections = @count.keys.count
@@ -77,20 +180,10 @@ class NioTcpPipeliningHandler < RubyDNS::GenericHandler
     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
+  def run(reactor: Async::Task.current.reactor)
+    @selector_threead = create_selector_thread
   end
 
   def accept
@@ -108,11 +201,11 @@ class NioTcpPipeliningHandler < RubyDNS::GenericHandler
     @server.class.stats.connection_accept(new_connection, @count.keys.count)
 
     #we read all data until timeout
-    input_data = RubyDNS::StreamTransport.read_chunk(socket)
+    input_data = PipelineTest.read_chunk(socket)
 
     if @count[socket] <= @max_requests_per_connection
       response = process_query(input_data, options)
-      RubyDNS::StreamTransport.write_message(socket, response)
+      Async::DNS::StreamTransport.write_message(socket, response)
     end
 
 =begin

data/test/test_utils.rb

@@ -1,5 +1,3 @@
-require_relative 'spec_helper'
-
 # Use this in tests in the tests directory with:
 # require_relative 'test_utils'
 # include TestUtils