dnsruby 1.59.0 → 1.59.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30959b577be6d8f64a67832ec6418fd157ece057
-  data.tar.gz: 94af23844c0a0f1d53b405b0720c9253364ad890
+  metadata.gz: 47fddae1c07436f1882cf04f2815f0f0f4e57991
+  data.tar.gz: 799ab6fe078f84d5ca9d651c4ca6701ed862a005
 SHA512:
-  metadata.gz: 2237405083ea6ba078a24a172d681b8fde6f770d61fab1617cf4683f576ade793af97edadabe2e76fd649dc0d1eb868eb8bd931021b151ad64b8d0f3c99fc271
-  data.tar.gz: b7f1a0e23ca45cbe15410bd604754c26688ca835edb39dcc340ac4aece8d76c3e67d6ed06a9c2c3488caf2d56c6a5d526fca80f1c6933b43c4e3f0f1ff7a6bce
+  metadata.gz: 7d83561ecdb469f15880d544c6d15b85f026700d24248a9e6c51804b85cc7a90da89be23a8d348b20dbe84519434e6f661b877881cac0bd533ea2fe9c8e7056c
+  data.tar.gz: 9969e39d04e70734c7ee077bfb137f7a36d1e2726a1ab0719cb31f322c34365a774efd7dd0edc2e11bd8418fa0d2a60250384e23bca35d0aca84a35c7011c467

data/RELEASE_NOTES.md

@@ -1,5 +1,11 @@
 # Release Notes
 
+## v1.59.1
+
+* Support for HMAC SHA512 TSIG keys
+* Fix TCP pipelining tests
+* IDN encoding error returned as Dnsruby::OtherResolvError
+
 ## v1.59.0
 
 * Add LICENSE file

data/Rakefile

@@ -31,3 +31,4 @@ create_task(:test_online,  'test/ts_online.rb')
 create_task(:soak,         'test/tc_soak.rb')
 create_task(:message,      'test/tc_message.rb')
 create_task(:cache,         'test/tc_cache.rb')
+create_task(:pipe,          'test/tc_tcp_pipelining.rb')

data/dnsruby.gemspec

@@ -35,6 +35,7 @@ DNSSEC NSEC3 support.'
   s.add_development_dependency 'minitest', '~> 5.4'
   s.add_development_dependency 'rubydns', '~> 1.0'
   s.add_development_dependency 'nio4r', '~> 1.1'
+  s.add_development_dependency 'minitest-display', '>= 0.3.0'
 
   if RUBY_VERSION >= "1.9.3"
     s.add_development_dependency 'coveralls', '~> 0.7'

data/lib/dnsruby/message/encoder.rb

@@ -15,7 +15,11 @@ class MessageEncoder #:nodoc: all
   end
 
   def put_pack(template, *d)
-    @data << d.pack(template)
+    begin
+      @data << d.pack(template)
+    rescue Encoding::CompatibilityError => e
+      raise Dnsruby::OtherResolvError.new("IDN support currently requires punycode string")
+    end
   end
 
   def put_length16
@@ -28,8 +32,12 @@ class MessageEncoder #:nodoc: all
   end
 
   def put_string(d)
-    self.put_pack("C", d.length)
-    @data << d
+    begin
+      self.put_pack("C", d.length)
+      @data << d
+    rescue Encoding::CompatibilityError => e
+      raise Dnsruby::OtherResolvError.new("IDN support currently requires punycode string")
+    end
   end
 
   def put_string_list(ds)

data/lib/dnsruby/packet_sender.rb

@@ -392,7 +392,7 @@ module Dnsruby
           end
         rescue Errno::EISCONN
           #already connected, do nothing and reuse!
-        rescue IOError #close by remote host, reconnect
+        rescue IOError, Errno::ECONNRESET #close by remote host, reconnect
           @pipeline_socket = nil
           Dnsruby.log.debug("Connection closed - recreating socket")
         end
@@ -401,21 +401,27 @@ module Dnsruby
       create_pipeline_socket = -> do
         @tcp_pipeline_local_port = src_port
         src_address = @ipv6 ? @src_address6 : @src_address
-
-        @pipeline_socket = Socket.new(AF_INET, SOCK_STREAM, 0)
-        @pipeline_socket.bind(Addrinfo.tcp(src_address, src_port))
-        @pipeline_socket.connect(sockaddr)
-        @use_counts[@pipeline_socket] = 0
+        begin
+          @pipeline_socket = Socket.new(AF_INET, SOCK_STREAM, 0)
+          @pipeline_socket.bind(Addrinfo.tcp(src_address, src_port))
+          @pipeline_socket.connect(sockaddr)
+          Dnsruby.log.debug("Creating socket #{src_address}:#{src_port}")
+          @use_counts[@pipeline_socket] = 0
+        rescue Exception => e
+          @pipeline_socket = nil
+          raise e
+        end
       end
 
       # Don't combine the following 2 statements; the reuse lambda can set the
       # socket to nil and if so we'd want to call the create lambda to recreate it.
       reuse_pipeline_socket.() if @pipeline_socket
+      new_socket = @pipeline_socket.nil?
       create_pipeline_socket.() unless @pipeline_socket
 
       @use_counts[@pipeline_socket] += 1
 
-      @pipeline_socket
+      [@pipeline_socket, new_socket]
     end
 
     #  This method sends the packet using the built-in pure Ruby event loop, with no dependencies.
@@ -437,10 +443,11 @@ module Dnsruby
           if (use_tcp)
             begin
               if (@tcp_pipelining)
-                socket = tcp_pipeline_socket(src_port)
+                socket, new_socket = tcp_pipeline_socket(src_port)
                 src_port = @tcp_pipeline_local_port
               else
                 socket = TCPSocket.new(@server, @port, src_address, src_port)
+                new_socket = true
               end
             rescue Errno::EBADF, Errno::ENETUNREACH => e
               #  Can't create a connection
@@ -458,6 +465,7 @@ module Dnsruby
               #               ipv6 = @src_address =~ /:/
               socket = UDPSocket.new(@ipv6 ? Socket::AF_INET6 : Socket::AF_INET)
             end
+            new_socket = true
             socket.bind(src_address, src_port)
             socket.connect(@server, @port)
           end
@@ -465,7 +473,8 @@ module Dnsruby
         rescue Exception => e
           if (socket!=nil)
             begin
-              socket.close
+              #let the select thread close the socket if tcp_pipeli
+              socket.close unless @tcp_pipelining && !new_socket
             rescue Exception
             end
           end
@@ -473,9 +482,15 @@ module Dnsruby
           #  Maybe try a max number of times?
           if ((e.class != Errno::EADDRINUSE) || (numtries > 50) ||
               ((e.class == Errno::EADDRINUSE) && (src_port == @src_port[0])))
-            err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
-            Dnsruby.log.error { "#{err}" }
-            st.push_exception_to_select(client_query_id, client_queue, err, nil)
+            err_msg = "dnsruby can't connect to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e} #{e.backtrace}"
+            err=IOError.new(err_msg)
+            Dnsruby.log.error( "#{err}")
+            Dnsruby.log.error(e.backtrace)
+            if @tcp_pipelining
+              st.push_exception_to_select(client_query_id, client_queue, SocketEofResolvError.new(err_msg), nil)
+            else
+              st.push_exception_to_select(client_query_id, client_queue, err, nil)
+            end
             return
           end
         end
@@ -498,15 +513,24 @@ module Dnsruby
           socket.send(lenmsg, 0)
         end
         socket.send(query_bytes, 0)
-        #  The select thread will now wait for the response and send that or a timeout
-        #  back to the client_queue.
+
+        #  The select thread will now wait for the response and send that or a
+        #  timeout back to the client_queue.
         st.add_to_select(query_settings)
       rescue Exception => e
-        err=IOError.new("Send failed to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}, exception : #{e}")
+        err_msg = "Send failed to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}, exception : #{e}"
+        err=IOError.new(err_msg)
         Dnsruby.log.error { "#{err}" }
-        st.push_exception_to_select(client_query_id, client_queue, err, nil)
+        Dnsruby.log.error(e.backtrace)
+        if @tcp_pipelining
+          st.push_exception_to_select(client_query_id, client_queue, SocketEofResolvError.new(err_msg), nil) if new_socket
+        else
+          st.push_exception_to_select(client_query_id, client_queue, err, nil)
+        end
         begin
-          socket.close
+          #we let the select_thread close the socket when doing tcp
+          #pipelining
+          socket.close unless @tcp_pipelining && !new_socket
         rescue Exception
         end
         return

data/lib/dnsruby/resource/TSIG.rb

@@ -54,6 +54,7 @@ module Dnsruby
       HMAC_MD5 = Name.create("HMAC-MD5.SIG-ALG.REG.INT.")
       HMAC_SHA1 = Name.create("hmac-sha1.")
       HMAC_SHA256 = Name.create("hmac-sha256.")
+      HMAC_SHA512 = Name.create("hmac-sha512.")
 
       DEFAULT_FUDGE     = 300
 
@@ -157,6 +158,8 @@ module Dnsruby
           mac = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA1.new, key, data)
         elsif (algorithm == HMAC_SHA256)
           mac = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, key, data)
+        elsif (algorithm == HMAC_SHA512)
+          mac = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA512.new, key, data)
         else
           #  Should we allow client to pass in their own signing function?
           raise VerifyError.new("Algorithm #{algorithm} unsupported by TSIG")
@@ -515,6 +518,7 @@ module Dnsruby
       # * hmac-md5
       # * hmac-sha1
       # * hmac-sha256
+      # * hmac-sha512
       def algorithm=(alg)
         if (alg.class == String)
           if (alg.downcase=="hmac-md5")
@@ -523,11 +527,13 @@ module Dnsruby
             @algorithm = HMAC_SHA1;
           elsif (alg.downcase=="hmac-sha256")
             @algorithm = HMAC_SHA256;
+          elsif (alg.downcase=="hmac-sha512")
+            @algorithm = HMAC_SHA512;
           else
             raise ArgumentError.new("Invalid TSIG algorithm")
           end
         elsif (alg.class == Name)
-          if (alg!=HMAC_MD5 && alg!=HMAC_SHA1 && alg!=HMAC_SHA256)
+          if (alg!=HMAC_MD5 && alg!=HMAC_SHA1 && alg!=HMAC_SHA256 && alg!=HMAC_SHA512)
             raise ArgumentException.new("Invalid TSIG algorithm")
           end
           @algorithm=alg
@@ -590,4 +596,4 @@ module Dnsruby
       end
     end
   end
-end
+end

data/lib/dnsruby/version.rb

@@ -1,3 +1,3 @@
 module Dnsruby
-  VERSION = '1.59.0'
+  VERSION = '1.59.1'
 end

data/test/spec_helper.rb

@@ -14,7 +14,17 @@ end
 
 require 'minitest'
 require 'minitest/autorun'
+require 'minitest/display'
 
+MiniTest::Display.options = {
+  suite_names: true,
+  color: true,
+  print: {
+    success: ".",
+    failure: "F",
+    error: "R"
+  }
+}
 # This is in a self invoking anonymous lambda so local variables do not
 # leak to the outer scope.
 -> do

data/test/tc_cache.rb

@@ -67,27 +67,27 @@ class TestCache < Minitest::Test
     Dnsruby::Cache.max_size=1
     res = Resolver.new()
     Dnsruby::PacketSender.clear_caches()
-    assert (Dnsruby::PacketSender.recursive_cache_length == 0)
+    assert(Dnsruby::PacketSender.recursive_cache_length == 0)
     msg = res.query("example.com")
-    assert (!msg.cached)
-    assert (Dnsruby::PacketSender.recursive_cache_length == 1)
+    assert(!msg.cached)
+    assert(Dnsruby::PacketSender.recursive_cache_length == 1)
     msg = res.query("example.com")
-    assert (msg.cached)
-    assert (Dnsruby::PacketSender.recursive_cache_length == 1)
+    assert(msg.cached)
+    assert(Dnsruby::PacketSender.recursive_cache_length == 1)
     msg = res.query("google.com")
-    assert (!msg.cached)
-    assert (Dnsruby::PacketSender.recursive_cache_length == 1)
+    assert(!msg.cached)
+    assert(Dnsruby::PacketSender.recursive_cache_length == 1)
     msg = res.query("example.com")
-    assert (!msg.cached)
-    assert (Dnsruby::PacketSender.recursive_cache_length == 1)
+    assert(!msg.cached)
+    assert(Dnsruby::PacketSender.recursive_cache_length == 1)
     Dnsruby::Cache.max_size=2
-    assert (Dnsruby::PacketSender.recursive_cache_length == 1)
+    assert(Dnsruby::PacketSender.recursive_cache_length == 1)
     msg = res.query("example.com")
-    assert (msg.cached)
-    assert (Dnsruby::PacketSender.recursive_cache_length == 1)
+    assert(msg.cached)
+    assert(Dnsruby::PacketSender.recursive_cache_length == 1)
     msg = res.query("google.com")
-    assert (!msg.cached)
-    assert (Dnsruby::PacketSender.recursive_cache_length == 2)
+    assert(!msg.cached)
+    assert(Dnsruby::PacketSender.recursive_cache_length == 2)
   end
 
   def test_resolver_do_caching
@@ -98,7 +98,7 @@ class TestCache < Minitest::Test
     res.do_caching = false
     assert(!res.do_caching)
     res.udp_size = 4096
-    ret = res.query("overflow.net-dns.org", Types.TXT)
+    ret = res.query("net-dns.org", Types.TXT)
     # ret = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
 #    print "#{ret}\n"
     assert(!ret.cached)
@@ -106,12 +106,12 @@ class TestCache < Minitest::Test
     assert(ret.header.aa)
     #  Store the ttls
     first_ttls = ret.answer.rrset(
-      "overflow.net-dns.org", Types.TXT).ttl
+      "net-dns.org", Types.TXT).ttl
       # "overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT).ttl
     #  Wait a while
     sleep(1)
     #  Ask for the same records
-    ret = res.query("overflow.net-dns.org", Types.TXT)
+    ret = res.query("net-dns.org", Types.TXT)
     # ret = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
 #    print "#{ret}\n"
     assert(ret.rcode == RCode.NoError)
@@ -125,7 +125,7 @@ class TestCache < Minitest::Test
     res = SingleResolver.new("ns.nlnetlabs.nl.")
     # res = SingleResolver.new("ns0.validation-test-servers.nominet.org.uk.")
     res.udp_size = 4096
-    query = Message.new("overflow.net-dns.org", Types.TXT)
+    query = Message.new("net-dns.org", Types.TXT)
     # query = Message.new("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
     ret = res.send_message(query)
 #    print "#{ret}\n"
@@ -134,19 +134,19 @@ class TestCache < Minitest::Test
     assert(ret.header.aa)
     #  Store the ttls
     first_ttls = ret.answer.rrset(
-      "overflow.net-dns.org", Types.TXT).ttl
+      "net-dns.org", Types.TXT).ttl
       # "overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT).ttl
     #  Wait a while
     sleep(1)
     #  Ask for the same records
-    query = Message.new("overflow.net-dns.org", Types.TXT)
+    query = Message.new("net-dns.org", Types.TXT)
     # query = Message.new("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
     ret = res.send_message(query)
 #    print "#{ret}\n"
     assert(ret.rcode == RCode.NoError)
     assert(ret.cached)
     second_ttls = ret.answer.rrset(
-      "overflow.net-dns.org", Types.TXT).ttl
+      "net-dns.org", Types.TXT).ttl
       # "overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT).ttl
     #  make sure the ttl is less the time we waited
     assert((second_ttls == first_ttls - 1) || (second_ttls == first_ttls - 2),

data/test/tc_single_resolver.rb

@@ -195,20 +195,20 @@ class TestSingleResolver < Minitest::Test
     assert_equal('10.0.1.128', ip.to_s, 'nameserver() looks up cname.')
   end
 
-  def test_truncated_response
-    res = SingleResolver.new
-    #     print "Dnssec = #{res.dnssec}\n"
-    # res.server=('ns0.validation-test-servers.nominet.org.uk')
-    res.server=('ns.nlnetlabs.nl')
-    res.packet_timeout = 15
-    begin
-      m = res.query("overflow.net-dns.org", 'txt')
-      assert(m.header.ancount == 62, "62 answer records expected, got #{m.header.ancount}")
-      assert(!m.header.tc, "Message was truncated!")
-    rescue ResolvTimeout => e
-    rescue ServFail => e # not sure why, but we get this on Travis...
-    end
-  end
+  # def test_truncated_response
+    # res = SingleResolver.new
+    # #     print "Dnssec = #{res.dnssec}\n"
+    # # res.server=('ns0.validation-test-servers.nominet.org.uk')
+    # res.server=('ns.nlnetlabs.nl')
+    # res.packet_timeout = 15
+    # begin
+      # m = res.query("overflow.net-dns.org", 'txt')
+      # assert(m.header.ancount == 62, "62 answer records expected, got #{m.header.ancount}")
+      # assert(!m.header.tc, "Message was truncated!")
+    # rescue ResolvTimeout => e
+    # rescue ServFail => e # not sure why, but we get this on Travis...
+    # end
+  # end
 
   def test_illegal_src_port
     #  Try to set src_port to an illegal value - make sure error raised, and port OK

data/test/tc_tcp_pipelining.rb

@@ -17,27 +17,30 @@
 require_relative 'spec_helper'
 require_relative 'test_dnsserver'
 
-# The TCPPipeliningServer links our TCPPipeliningHandler on
+# The TCPPipeliningServer links our NioTcpPipeliningHandler on
 # the loopback interface.
-class TCPPipeliningServer < RubyDNS::RuleBasedServer
-
-  PORT = 53937
+class TCPPipeliningServer < RubyDNS::Server
+  PORT     = 53937
   IP   = '127.0.0.1'
 
+  DEFAULT_MAX_REQUESTS = 4
+  DEFAULT_TIMEOUT = 3
+
   @@stats = Stats.new
 
   def self.stats
     @@stats
   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
+
   def run
     fire(:setup)
 
-    link TCPPipeliningHandler.new(self,
-                                  IP,
-                                  PORT,
-                                  TCPPipeliningHandler::DEFAULT_MAX_REQUESTS,
-                                  TCPPipeliningHandler::DEFAULT_TIMEOUT)
+    link NioTcpPipeliningHandler.new(self, IP, PORT, DEFAULT_MAX_REQUESTS, DEFAULT_TIMEOUT) #4 max request
 
     fire(:start)
   end
@@ -45,8 +48,6 @@ 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
@@ -56,6 +57,7 @@ class TestTCPPipelining < Minitest::Test
       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
@@ -63,9 +65,6 @@ class TestTCPPipelining < Minitest::Test
 
   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)
@@ -74,11 +73,7 @@ class TestTCPPipelining < Minitest::Test
         asynchronous: true
     }
 
-    @@supervisor ||= RubyDNS::run_server(options) do
-      otherwise do |transaction|
-        transaction.passthrough!(@@upstream)
-      end
-    end
+    @@supervisor ||= RubyDNS::run_server(options)
 
     # 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
@@ -95,9 +90,11 @@ class TestTCPPipelining < Minitest::Test
 
   # Send x number of queries asynchronously to our resolver
   def send_async_messages(number_of_messages, queue, wait_seconds = 0)
-    query_cycler = QUERIES.cycle
+    Celluloid.logger.debug "Sending #{number_of_messages} messages"
     number_of_messages.times do
-      message = Dnsruby::Message.new(query_cycler.next)
+      name = "#{self.class.query_id}.com"
+      Celluloid.logger.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
@@ -117,9 +114,39 @@ class TestTCPPipelining < Minitest::Test
     end
   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}")
+    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}")
+    end
+  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}")
+    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
+    Celluloid.logger.debug "test_TCP_pipelining_timeout"
+    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
+
     accept_count  = TCPPipeliningServer.stats.accept_count
     timeout_count = TCPPipeliningServer.stats.timeout_count
 
@@ -133,8 +160,8 @@ class TestTCPPipelining < Minitest::Test
 
     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
+    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)
 
@@ -142,39 +169,48 @@ class TestTCPPipelining < Minitest::Test
     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
+    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)
   end
 
   # 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"
+    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 3 queries but wait 3s after each query.
+    # 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(3, query_queue, TCPPipeliningHandler::DEFAULT_TIMEOUT / 2.0 + 0.5)
-    verify_responses(3, query_queue)
+    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)
 
-    sleep TCPPipeliningHandler::DEFAULT_TIMEOUT + 0.5
+    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
 
-    assert_equal(timeout_count + 2, TCPPipeliningServer.stats.timeout_count)
+    timeout_wait(timeout_count + 2, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
   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
+    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
 
     query_queue = Queue.new
 
@@ -183,11 +219,21 @@ class TestTCPPipelining < Minitest::Test
     # Verify we got max_count was incremented
     send_async_messages(6, query_queue)
 
-    step = 0
+    responses = []
+
     6.times do
-      _response_id, response, exception = query_queue.pop
-      if step < TCPPipeliningHandler::DEFAULT_MAX_REQUESTS
-        assert_nil(exception)
+      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))
       else
         assert_equal(Dnsruby::SocketEofResolvError, exception.class)
@@ -196,8 +242,6 @@ class TestTCPPipelining < Minitest::Test
       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)
+    connection_wait(0, TCPPipeliningServer::DEFAULT_TIMEOUT*5)
   end
 end

data/test/test_dnsserver.rb

@@ -17,22 +17,62 @@
 require 'rubydns'
 require 'nio'
 require 'socket'
+require 'thread'
 
-# TCPPipeliningHandler accepts new tcp connection and reads data from the sockets until
+class SimpleTimers
+  def initialize
+    @events = {}
+  end
+
+  def empty?
+    @events.empty?
+  end
+
+  def after(seconds, &block)
+    eventTime = Time.now + seconds
+    @events[eventTime] ||= []
+    @events[eventTime] << block
+  end
+
+  def fire
+    now = Time.now
+
+    events = @events.select { |key, value| key <= now }
+
+    (events || []).each do |key, blocks|
+      blocks.each do |block|
+        block.call
+      end
+      @events.delete(key)
+    end
+  end
+
+  def wait_interval
+    next_event = @events.keys.min
+    next_event.nil? ? nil : next_event - Time.now
+  end
+end
+
+# NioTcpPipeliningHandler 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
-
+  DEFAULT_TIMEOUT = 3
   # TODO Add timeout
-  def initialize(server, host, port, max_requests = DEFAULT_MAX_REQUESTS)
+  def initialize(server, host, port, max_requests = DEFAULT_MAX_REQUESTS, timeout = DEFAULT_TIMEOUT)
     super(server)
     @max_requests_per_connection = max_requests
+    @timeout = timeout
     @socket = TCPServer.new(host, port)
     @count = {}
 
+    @server.class.stats.connections = @count.keys.count
+
+    @timers = SimpleTimers.new
+
     @selector = NIO::Selector.new
     monitor = @selector.register(@socket, :r)
     monitor.value = proc { accept }
@@ -62,18 +102,26 @@ class NioTcpPipeliningHandler < RubyDNS::GenericHandler
     _, _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)
-
+    new_connection = @count[socket].nil?
     @count[socket] ||= 0
     @count[socket]  += 1
+    @server.class.stats.connection_accept(new_connection, @count.keys.count)
+
+    #we read all data until timeout
+    input_data = RubyDNS::StreamTransport.read_chunk(socket)
 
+    if @count[socket] <= @max_requests_per_connection
+      response = process_query(input_data, options)
+      RubyDNS::StreamTransport.write_message(socket, response)
+    end
+
+=begin
     if @count[socket] >= @max_requests_per_connection
       _, port, host = socket.peeraddr
       @logger.debug("*** max request for #{host}:#{port}")
       remove(socket)
     end
+=end
   rescue EOFError
     _, port, host = socket.peeraddr
     @logger.debug("*** #{host}:#{port} disconnected")
@@ -81,118 +129,92 @@ class NioTcpPipeliningHandler < RubyDNS::GenericHandler
     remove(socket)
   end
 
-  def remove(socket)
+  def remove(socket, update_connections=true)
     @logger.debug("Removing socket from selector")
     socket.close rescue nil
-    @selector.deregister(socket)
-    @count.delete(socket)
+    @selector.deregister(socket) rescue nil
+    socket_count = @count.delete(socket)
+    @server.class.stats.connections = @count.keys.count if update_connections
+    socket_count
   end
 
   def create_selector_thread
     Thread.new do
       loop do
-        @selector.select { |monitor| monitor.value.call(monitor) }
-        break if @selector.closed?
+        begin
+          @timers.fire
+          intervals = [@timers.wait_interval || 0.1, 0.1]
+
+          @selector.select(intervals.min > 0 ? intervals.min : 0.1) do
+            |monitor| monitor.value.call(monitor)
+          end
+
+          @logger.debug "Woke up"
+          break if @selector.closed?
+        rescue Exception => e
+          @logger.debug "Exception #{e}"
+          @logger.debug "Backtrace #{e.backtrace}"
+        end
       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
+    @logger.debug "Add socket timer of #{@timeout}"
+    @timers.after(@timeout) do
+      @logger.debug "Timeout fired for socket #{socket}"
+      count = remove(socket, false)
+      unless count.nil?
+        @logger.debug "Timeout for socket #{socket}"
+        @logger.debug "Increasing timeout count"
+        @server.class.stats.connection_timeout(@count.keys.count)
       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
+    @mutex         = Mutex.new
+    @accept_count  = 0
     @timeout_count = 0
-    @max_count = 0
+    @max_count     = 0
+    @connections   = 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 connection_timeout(active_connections)
+    @mutex.synchronize do
+      @timeout_count += 1
+      @connections = active_connections
+    end
+  end
+
+  def connection_accept(new_connection, active_connections)
+    @mutex.synchronize {
+      @connections    = active_connections
+      @accept_count  += 1 if new_connection
+    }
+  end
+
+  def connections=(active_connections)
+    @mutex.synchronize { @connections = active_connections }
+  end
+
+  def connections
+    @mutex.synchronize { @connections }
+  end
+
   def accept_count
     @mutex.synchronize { @accept_count  }
   end
@@ -204,5 +226,4 @@ class Stats
   def max_count
     @mutex.synchronize { @max_count }
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dnsruby
 version: !ruby/object:Gem::Version
-  version: 1.59.0
+  version: 1.59.1
 platform: ruby
 authors:
 - Alex Dalitz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2016-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -100,6 +100,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: minitest-display
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement