dnsruby 1.1

data/test/tc_event_machine_deferrable.rb

@@ -0,0 +1,85 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'dnsruby'
+
+class EventMachineTestDeferrable < Test::Unit::TestCase
+  Dnsruby::Resolver.use_eventmachine(true)
+  def setup
+#    Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_deferrable_success
+    res = Dnsruby::SingleResolver.new
+    Dnsruby::Resolver.use_eventmachine
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    EM.run {
+      df = res.send_async(Dnsruby::Message.new("nominet.org.uk"))
+      df.callback {|msg| EM.stop}
+      df.errback {|msg, err| 
+        EM.stop 
+        assert(false)}
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_deferrable_timeout
+    res = Dnsruby::SingleResolver.new("10.0.1.128")
+    Dnsruby::Resolver.use_eventmachine
+    res.packet_timeout=2
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    EM.run {
+      df = res.send_async(Dnsruby::Message.new("nominet.org.uk"))
+      df.callback {|msg| EM.stop; assert(false)}
+      df.errback {|msg, err| 
+        EM.stop 
+        }
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+
+  def test_deferrable_success
+    sleep(0.1) # Give the Event loop a chance to close down from previous test
+    Dnsruby::Resolver.use_eventmachine
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    res = Dnsruby::Resolver.new
+    q = Queue.new
+    id = 1
+    EM.run {
+      df = res.send_async(Dnsruby::Message.new("nominet.org.uk"))
+      df.callback {|msg| done = true; EM.stop}
+      df.errback {|msg, err| 
+        puts "errback: #{msg}, #{err}"
+        done = true
+        EM.stop 
+        assert(false)}
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_deferrable_timeout
+    sleep(0.1) # Give the Event loop a chance to close down from previous test
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    Dnsruby::Resolver.use_eventmachine
+    res = Dnsruby::Resolver.new("10.0.1.128")
+    res.query_timeout=2
+    q = Queue.new
+    id = 1
+    EM.run {
+      df = res.send_async(Dnsruby::Message.new("nominet.org.uk"))
+      df.callback {|msg| EM.stop; assert(false)}
+      df.errback {|msg, err| 
+        EM.stop 
+      }
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+end

data/test/tc_event_machine_res.rb

@@ -0,0 +1,174 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'dnsruby'
+
+class EventMachineTestResolver < Test::Unit::TestCase
+  include Dnsruby
+  Dnsruby::Resolver.use_eventmachine(true)
+  Thread::abort_on_exception = true
+  def setup
+    Dnsruby::Config.reset
+    #    Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_send_message
+    res = Resolver.new
+    ret = res.send_message(Message.new("example.com", Types.A))
+    assert(ret.kind_of?(Message))
+  end
+  
+  def test_query
+    res = Resolver.new
+    ret = res.query("example.com")
+    assert(ret.kind_of?(Message))
+  end
+  
+  def test_query_async
+    res = Resolver.new
+    q = Queue.new
+    res.send_async(Message.new("example.com", Types.A),q,q)
+    id, ret, error = q.pop
+    assert_equal(id, q, "Id wrong!")
+    assert(ret.kind_of?(Message), "Ret wrong!")
+    assert(error==nil)
+  end
+  
+  def test_query_one_duff_server_one_good
+    res = Resolver.new({:nameserver => ["localhost", "128.8.10.90"]})
+    res.retry_delay=1
+    q = Queue.new
+    res.send_async(Message.new("example.com", Types.A),q,q)
+    id, ret, error = q.pop
+    assert_equal(id, q, "Id wrong!")
+    assert(ret.kind_of?(Message), "Ret wrong! (#{ret.class}")
+    assert(error==nil)
+  end
+  
+  def test_reverse_lookup
+    m = Message.new("210.251.121.214", Types.PTR)
+    r = Resolver.new
+    q=Queue.new
+    r.send_async(m,q,q)
+    id,ret, error=q.pop
+    assert(ret.kind_of?(Message))
+    no_pointer=true
+    ret.each_answer do |answer|
+      if (answer.type==Types.PTR)
+        no_pointer=false
+        assert(answer.domainname.to_s=~/ruby-lang/)      
+      end
+    end
+    assert(!no_pointer)
+  end
+  
+  def test_nxdomain
+    res=Resolver.new
+    q = Queue.new
+    res.send_async(Message.new("dklfjhdFHFHDVVUIEWRFDSAJKVCNASDLFJHN.com", Types.A), q, 1)
+    id, m, err = q.pop
+    assert(id==1)
+    assert(m.header.rcode == RCode.NXDOMAIN)
+    assert(err.kind_of?(NXDomain))
+  end
+  
+  def test_timeouts
+    #test timeout behaviour for different retry, retrans, total timeout etc.
+    #Problem here is that many sockets will be created for queries which time out. 
+    # Run a query which will not respond, and check that the timeout works
+    start=stop=0
+    retry_times = 3
+    retry_delay=1
+    packet_timeout=2
+    # Work out what time should be, then time it to check
+    expected = ((2**(retry_times-1))*retry_delay) + packet_timeout
+    begin
+      res = Resolver.new("10.0.1.128")
+      res.packet_timeout=packet_timeout
+      res.retry_times=retry_times
+      res.retry_delay=retry_delay
+      start=Time.now
+      m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
+      fail
+    rescue ResolvTimeout
+      stop=Time.now
+      time = stop-start
+      assert(time <= expected *1.1 && time >= expected *0.9, "Wrong time taken, expected #{expected}, took #{time}")        
+    end
+  end
+  
+  def test_query_timeout
+    res = Resolver.new({:nameserver => "10.0.1.128"})
+    start=stop=0
+    retry_times = retry_delay = packet_timeout= 10
+    query_timeout=2
+    begin
+      res.packet_timeout=packet_timeout
+      res.retry_times=retry_times
+      res.retry_delay=retry_delay
+      res.query_timeout=query_timeout
+      # Work out what time should be, then time it to check
+      expected = query_timeout
+      start=Time.now
+      m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
+      fail
+    rescue ResolvTimeout
+      stop=Time.now
+      time = stop-start
+      assert(time <= expected *1.1 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
+    end    
+  end
+  
+  def test_queue_query_timeout
+    res = Resolver.new({:nameserver => "10.0.1.128"})
+    bad = SingleResolver.new("localhost")
+    res.add_resolver(bad)
+    expected = 2
+    res.query_timeout=expected
+    q = Queue.new
+    start = Time.now
+    m = res.send_async(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A), q, q)
+    id,ret,err = q.pop
+    stop = Time.now
+    assert(id=q)
+    assert(ret==nil)
+    assert(err.class == ResolvTimeout, "#{err.class}, #{err}")
+    time = stop-start
+    assert(time <= expected *1.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")            
+  end
+  
+  
+  
+  def test_tcp
+    res = Dnsruby::Resolver.new
+    res.use_tcp = true
+    Dnsruby::Resolver.use_eventmachine
+    q = Queue.new
+    id = 1
+    res.send_async(Dnsruby::Message.new("nominet.org.uk"), q, id)
+    id+=1
+    res.send_async(Dnsruby::Message.new("example.com"), q, id)
+    id.times do |i|
+      itemid = q.pop[0]
+      assert(itemid <= id)
+      assert(itemid >= 0)
+    end
+  end
+  
+  def test_truncated_response
+    res = Dnsruby::Resolver.new('ns0.validation-test-servers.nominet.org.uk')
+    res.packet_timeout = 10
+    m = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", 'txt')
+    assert(m.header.ancount == 61, "61 answer records expected, got #{m.header.ancount}")
+    assert(!m.header.tc, "Message was truncated!")
+  end
+  
+end

data/test/tc_event_machine_single_res.rb

@@ -0,0 +1,101 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'dnsruby'
+
+class EventMachineTestSingleResolver < Test::Unit::TestCase
+  Dnsruby::Resolver.use_eventmachine(true)
+  def setup
+#    Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+    sleep(0.01)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  def test_udp
+    res = Dnsruby::SingleResolver.new
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+    q = Queue.new
+    id = 1
+    res.send_async(Dnsruby::Message.new("nominet.org.uk"), q, id)
+    id+=1
+    res.send_async(Dnsruby::Message.new("example.com"), q, id)
+    id.times do |i|
+      item = q.pop
+      assert(item[1].class==Dnsruby::Message)
+      assert(item[0] <= id)
+      assert(item[0] >= 0)
+    end
+  end
+  
+  def test_tcp
+    res = Dnsruby::SingleResolver.new
+    res.use_tcp = true
+    Dnsruby::Resolver.use_eventmachine
+    q = Queue.new
+    id = 1
+    res.send_async(Dnsruby::Message.new("nominet.org.uk"), q, id)
+    id+=1
+    res.send_async(Dnsruby::Message.new("example.com"), q, id)
+    id.times do |i|
+      itemid, response, error = q.pop
+      assert(itemid <= id)
+      assert(itemid >= 0)
+      assert(error==nil)
+    end
+    #@TODO@ How do we check that TCP was actually used? Do we need a test server for this?
+    #Or will the truncated test catch this? (Query retried over TCP to fetch all records)
+  end
+  
+  def test_tcp_queue_timeout
+    res = Dnsruby::SingleResolver.new("10.0.1.128")
+    Dnsruby::Resolver.use_eventmachine(true)
+    res.packet_timeout=2
+    res.use_tcp=true
+    q = Queue.new
+    msg = Dnsruby::Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+    res.send_async(msg, q, 1)
+    start=Time.now
+    id,ret,error = q.pop
+    end_time = Time.now
+    assert(id==1)
+    assert(ret==nil)
+    assert(error.class == Dnsruby::ResolvTimeout)
+#    p "Difference = #{end_time-start}"
+    assert(end_time - start >= 1.9)
+    assert(end_time - start <= 2.2)
+  end
+  
+  def test_udp_queue_timeout
+    res = Dnsruby::SingleResolver.new("10.0.1.128")
+    Dnsruby::Resolver.use_eventmachine(true)
+    res.packet_timeout=2
+    q = Queue.new
+    start=Time.now
+    msg = Dnsruby::Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+    res.send_async(msg, q, 1)
+    id,ret,error = q.pop
+    end_time = Time.now
+    assert(id==1)
+    assert(ret==nil)
+#    p "Difference = #{end_time-start}"
+    assert(error.class == Dnsruby::ResolvTimeout)
+    assert(end_time - start >= 1.9)
+    assert(end_time - start <= 2.2)
+  end
+  
+  def test_truncated_response
+   res = Dnsruby::SingleResolver.new
+    res.packet_timeout = 10
+    res.server=('ns0.validation-test-servers.nominet.org.uk')
+    m = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", 'txt')
+    assert(m.header.ancount == 61, "61 answer records expected, got #{m.header.ancount}")
+    assert(!m.header.tc, "Message was truncated!")
+  end
+end

data/test/tc_event_machine_soak.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+require 'test/unit'
+require 'eventmachine'
+require 'dnsruby'
+begin
+  require 'test/tc_soak_base'
+rescue Exception
+  require 'tc_soak_base'
+end
+
+class TestEventMachineSoak < Test::Unit::TestCase
+  def setup
+    #    Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+  end
+  def teardown
+    Dnsruby::Resolver.use_eventmachine(false)    
+  end
+  def test_single_res
+    #    TestSoakBase.test_continuous_queries_asynch_single_res
+  end
+  def test_single_deferrable
+    sleep(0.1)
+    @@dfs = {}
+    @@num_sent = 0
+    #Dnsruby::TheLog.level=Logger::DEBUG
+    res = Dnsruby::SingleResolver.new
+    Dnsruby::Resolver.use_eventmachine
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    q = Queue.new
+    id = 1
+    done = false
+    EM.run {
+      100.times do |i|
+        send_next_deferrable(res)
+      end
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+  end
+  
+  def test_sequential
+    #Dnsruby::TheLog.level=Logger::DEBUG
+    Dnsruby::Resolver.use_eventmachine(true)
+    Dnsruby::Resolver.start_eventmachine_loop(true)
+    res = Dnsruby::SingleResolver.new
+    res.packet_timeout = 2
+    q = Queue.new
+    240.times do |i|
+      puts i
+      res.send_async(Dnsruby::Message.new("example#{i}.com"), q, i)      
+    end
+    240.times do |i|
+      puts "Receiving #{i}"
+      id, msg, error = q.pop
+      if (error != nil)
+        puts ("Error : #{error}")
+      end
+    end
+  end
+  
+  def test_resolver_deferrable
+    sleep(0.1)
+    @@dfs = {}
+    @@num_sent = 0
+    #Dnsruby::TheLog.level=Logger::DEBUG
+    res = Dnsruby::Resolver.new
+    Dnsruby::Resolver.use_eventmachine
+    Dnsruby::Resolver.start_eventmachine_loop(false)
+    q = Queue.new
+    id = 1
+    done = false
+    EM.run {
+      50.times do |i|
+        send_next_deferrable(res)
+      end
+    }
+    Dnsruby::Resolver.start_eventmachine_loop(true)    
+  end
+
+  def send_next_deferrable(res)
+    if (@@num_sent>2000) 
+      EM.stop
+      return
+    end
+    id = @@num_sent
+    @@num_sent+=1
+    @@dfs[id] = res.send_async(Dnsruby::Message.new("example.com"))
+    @@dfs[id].callback {|msg| puts "callback: #{id}"
+      @@dfs.delete(id)
+      send_next_deferrable(res)
+    }
+    @@dfs[id].errback {|msg, err| 
+      @@dfs.delete(id)
+      puts "errback: #{id}, #{err}"
+      send_next_deferrable(res)
+    }
+  end  
+end