dnsruby 1.1

data/test/tc_soak.rb

@@ -0,0 +1,200 @@
+#--
+#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. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+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
+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 TestSingleResolverSoak < Test::Unit::TestCase
+  
+  def test_many_asynchronous_queries_one_single_resolver
+    run_many_asynch_queries_test_single_res(1)
+  end
+  
+  def test_many_asynchronous_queries_many_single_resolvers
+    run_many_asynch_queries_test_single_res(50)
+  end
+  
+  def run_many_asynch_queries_test_single_res(num_resolvers)
+    q = Queue.new
+    resolvers = []
+    timed_out = 0
+    query_count = 0
+    num_resolvers.times do |n|
+      resolvers.push(SingleResolver.new)
+      resolvers[n].packet_timeout=4
+    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
+        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
+      
+    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
+  
+  
+  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
+    ids = []
+    mutex = Mutex.new
+    timed_out = 0
+    query_count = 0
+    res.packet_timeout=4
+    start=Time.now
+    # Windows limits us to 256 sockets
+    num_times=250
+    if (/java/ =~ RUBY_PLATFORM)
+      # JRuby threads are native threads, so let's not go too mad!
+      num_times=50
+    end        
+    num_times.times do |i|
+      threads[i] = Thread.new{
+        40.times do |j|
+          TestSoakBase::Rrs.each do |data|
+            mutex.synchronize do
+              query_count+=1
+            end
+            packet=nil
+            begin
+              packet = res.query(data[:name], data[:type])
+            rescue ResolvTimeout
+              mutex.synchronize {
+                timed_out+=1
+              }
+              next
+            end
+            assert(packet)
+            ids.push(packet.header.id)
+            assert_equal(packet.question[0].qclass,    'IN',             'Class correct'           )
+          end
+        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"
+    #    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!")
+  end
+  
+  def check_ids(ids)
+    ids.sort!
+    count = 0
+    ids.each do |id|
+      count+=1
+      if (count < ids.length-1)
+        assert(ids[count+1] != id, "Two identical header ids used!")
+      end
+    end
+  end
+  
+  def test_many_threads_on_many_single_resolvers
+    # Test multi-threaded behaviour
+    # @todo@ Check the header IDs to make sure they're all different
+    threads = Array.new
+    mutex = Mutex.new
+    timed_out = 0
+    query_count = 0
+    start=Time.now
+    num_times=250
+    if (/java/ =~ RUBY_PLATFORM)
+      # JRuby threads are native threads, so let's not go too mad!
+      num_times=50
+    end        
+    num_times.times do |i|
+      threads[i] = Thread.new{
+        res = SingleResolver.new
+        res.packet_timeout=4
+        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])
+            id, packet, error = q.pop
+            if (error.class == ResolvTimeout)
+              mutex.synchronize {
+                timed_out+=1
+              }
+              next
+            elsif (packet.class!=Message)
+              p "ERROR! #{error}"
+            end
+            
+            assert(packet)
+            assert_equal(packet.question[0].qclass,    'IN',             'Class correct'           )
+          end
+        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!")
+  end
+  
+  
+end

data/test/tc_soak_base.rb

@@ -0,0 +1,136 @@
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+
+class TestSoakBase # < Test::Unit::TestCase
+  include Dnsruby
+  Rrs = [
+  {
+    :type   		=> Types.A,
+    :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+    :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		=> 'CNAME',
+    :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
+    :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']
+  }		
+  ]		
+
+  def TestSoakBase.test_continuous_queries_asynch_single_res
+    # Have two threads looping, with one sending, and one receiving queries.
+    # Never exceed more than 200 concurrent queries, but make sure they're always running.
+    outstanding_limit = 1
+    num_loops = 2000
+    num_sent = 0
+    q = Queue.new
+    timed_out = 0
+    mutex = Mutex.new
+    start = Time.now
+    num_in_progress = 0
+    sender = Thread.new{
+      res = SingleResolver.new
+      res.packet_timeout=5
+      num_loops.times do |i|
+        rr_count = 0
+        Rrs.each do |data|
+          rr_count+=1
+          while (mutex.synchronize{num_in_progress> outstanding_limit}) do
+            sleep(0.01)
+          end
+          res.send_async(Message.new(data[:name], data[:type]), q, [i,rr_count])
+          puts num_sent
+          num_sent+=1
+          mutex.synchronize {
+            num_in_progress+=1
+          }
+        end
+      end
+      
+    }
+    receiver = Thread.new{
+     (num_loops*4).times do |i|
+        id,ret, error = q.pop
+        mutex.synchronize {
+          num_in_progress-=1
+        }
+        if (error.class == ResolvTimeout)
+          timed_out+=1
+          #        p "Number #{i} timed out!"
+        elsif (ret.class != Message)
+          TheLog.debug("tc_single_resolver : Query #{i} ERROR RETURNED : #{error.class}, #{error}")
+        end
+      end
+    }
+    sender.join
+    receiver.join
+    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"
+    assert(timed_out < num_sent * 0.1, "#{timed_out} of #{num_sent} timed out!")
+  end
+  
+  def TestSoakBase.test_continuous_queries_asynch_resolver
+    # Have two threads looping, with one sending, and one receiving queries.
+    # Never exceed more than 250 concurrent queries, but make sure they're always running.
+    num_loops = 1000
+    num_sent = 0
+    q = Queue.new
+    timed_out = 0
+    mutex = Mutex.new
+    start = Time.now
+    num_in_progress = 0
+    sender = Thread.new{
+      res = Resolver.new
+      # 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.
+      num_loops.times do |i|
+        while (mutex.synchronize{num_in_progress> 50}) do # One query has several sockets in Resolver
+          sleep(0.01)
+        end
+        res.send_async(Message.new("example.com", Types.A), q, [i,1])
+        num_sent+=1
+        mutex.synchronize {
+          num_in_progress+=1
+        }
+      end
+    }
+    error_count=0
+    receiver = Thread.new{
+     (num_loops).times do |i|
+        id,ret, error = q.pop
+        mutex.synchronize {
+          num_in_progress-=1
+        }
+        if (error.class == ResolvTimeout)
+          timed_out+=1
+          #        p "Number #{i} timed out!"
+        elsif (ret.class != Message)
+          error_count+=1
+          TheLog.error("tc_single_resolver : Query #{i} ERROR RETURNED : #{error.class}, #{error}")
+        end
+      end
+    }
+    sender.join
+    receiver.join
+    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"
+    assert(timed_out < num_sent * 0.1, "#{timed_out} of #{num_sent} timed out!")
+    assert(error_count == 0)
+  end
+end

data/test/tc_tcp.rb

@@ -0,0 +1,35 @@
+#--
+#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. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+class TestTcp < Test::Unit::TestCase
+  def test_TCP
+    res = Dnsruby::Resolver.new()
+    res.use_tcp = true
+    ret=res.query("example.com")
+    assert(ret.is_a?(Dnsruby::Message))
+  end
+  def test_TCP_port
+    #@TODO@ Need a test server so we can tell what port this message was actually sent on!
+    res = Dnsruby::Resolver.new()
+    res.use_tcp = true
+    res.src_port=5379
+    ret=res.query("example.com")
+    assert(ret.is_a?(Dnsruby::Message))
+  end
+  #@TODO@ Check stuff like persistent sockets
+end

data/test/tc_tkey.rb

@@ -0,0 +1,75 @@
+#--
+#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. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+require "digest/md5"
+class TestTKey < Test::Unit::TestCase
+  def is_empty(string)
+    return (string == "; no data" || string == "; rdlength = 0")
+  end
+  
+  def test_tkey
+    
+    
+    #------------------------------------------------------------------------------
+    # 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
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # Packet creation.
+    #------------------------------------------------------------------------------
+    
+    rr = Dnsruby::RR.create(
+      :name       => name,
+      :type       => "TKEY",
+      :ttl        => 0,
+      :klass      => "ANY",
+      :algorithm  => algorithm,
+      :inception  => inception,
+      :expiration => expiration,
+      :mode       => 3, # GSSAPI
+      :key        => "fake key",
+      :other_data => ""
+    )
+    
+    packet = Dnsruby::Message.new(name, Dnsruby::Types.TKEY, "IN")
+    packet.add_answer(rr)
+    
+    z = (packet.zone)[0]
+    
+    assert(packet,                                'new() returned packet')  #2
+    assert_equal(Dnsruby::OpCode.QUERY,       packet.header.opcode, 'header opcode correct')  #3 
+    assert_equal(name,                      z.zname.to_s,  'zname correct')          #4
+    assert_equal(Dnsruby::Classes.IN,                       z.zclass, 'zclass correct')         #5
+    assert_equal(Dnsruby::Types.TKEY,                     z.ztype,  'ztype correct')          #6       
+    
+    #@TODO@ Test TKEY against server!
+    
+  end
+  end

data/test/tc_tsig.rb

@@ -0,0 +1,237 @@
+#--
+#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. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+require "digest/md5"
+class TestTSig < Test::Unit::TestCase
+  KEY_NAME="rubytsig"
+  KEY = "8n6gugn4aJ7MazyNlMccGKH1WxD2B3UvN/O/RA6iBupO2/03u9CTa3Ewz3gBWTSBCH3crY4Kk+tigNdeJBAvrw=="
+  def is_empty(string)
+    return (string == "; no data" || string == "; rdlength = 0")
+  end
+  def test_signed_update
+    Dnsruby::Resolver::use_eventmachine(false)
+    run_test_client_signs
+    run_test_resolver_signs
+  end
+  def test_signed_update_em
+    begin
+      Dnsruby::Resolver::use_eventmachine(true)
+    rescue RuntimeError
+      Dnsruby::TheLog.error("EventMachine not installed - not running tsig EM tests")
+      return 
+    end
+    run_test_client_signs
+    run_test_resolver_signs
+    Dnsruby::Resolver::use_eventmachine(false)
+  end
+  
+  def run_test_client_signs
+    # NOTE - client signing is only appropriate if DNSSEC and EDNS are switched
+    # off. Otherwise, the resolver will attempt to alter the flags and add an
+    # EDNS OPT psuedo-record to the query message, invalidating the signing.
+    tsig = Dnsruby::RR.create({
+        :name        => KEY_NAME,
+        :type        => "TSIG",
+        :ttl         => 0,
+        :klass       => "ANY",
+        :algorithm   => "hmac-md5",
+        :fudge       => 300,
+        :key         => KEY,
+        :error       => 0
+      })
+    
+    update = Dnsruby::Update.new("validation-test-servers.nominet.org.uk")
+    # Generate update record name, and test it has been made. Then delete it and check it has been deleted
+    update_name = generate_update_name
+    update.absent(update_name)
+    update.add(update_name, 'TXT', 100, "test signed update")
+    tsig.apply(update)
+    assert(update.signed?, "Update has not been signed")
+    
+    res = Dnsruby::Resolver.new("ns0.validation-test-servers.nominet.org.uk")
+    res.udp_size=512 # Or else we needed to add OPT record already
+    res.dnssec=false
+    res.recurse=false
+    res.query_timeout = 10
+    response = res.send_message(update)
+    
+    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert(response.verified?, "Response has not been verified")
+    
+    # Now check the record exists
+    rr = res.query(update_name, 'TXT')
+    assert_equal("test signed update", rr.answer()[0].strings.join(" "), "TXT record has not been created in zone")
+    
+    # Now delete the record
+    update = Dnsruby::Update.new("validation-test-servers.nominet.org.uk")
+    update.present(update_name, 'TXT')
+    update.delete(update_name)
+    tsig.apply(update)
+    assert(update.signed?, "Update has not been signed")
+    response = res.send_message(update)
+    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert(response.verified?, "Response has not been verified")
+    
+    # Now check the record does not exist
+    begin
+      rr = res.query(update_name, 'TXT')
+      assert(false)
+    rescue Dnsruby::NXDomain
+    end
+  end
+  
+  @@fudge = 0
+  def generate_update_name
+    update_name = Time.now.to_i.to_s + @@fudge.to_s
+    @@fudge+=1
+    update_name += ".update.validation-test-servers.nominet.org.uk"
+    return update_name
+  end
+  
+  def run_test_resolver_signs
+    res = Dnsruby::Resolver.new("ns0.validation-test-servers.nominet.org.uk")
+    res.query_timeout=10
+    res.tsig=KEY_NAME, KEY
+    
+    update = Dnsruby::Update.new("validation-test-servers.nominet.org.uk")
+    # Generate update record name, and test it has been made. Then delete it and check it has been deleted
+    update_name = generate_update_name
+    update.absent(update_name)
+    update.add(update_name, 'TXT', 100, "test signed update")
+    assert(!update.signed?, "Update has been signed")
+    
+    response = res.send_message(update)
+    
+    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert(response.verified?, "Response has not been verified")
+    
+    # Now check the record exists
+    rr = res.query(update_name, 'TXT')
+    assert_equal("test signed update", rr.answer()[0].strings.join(" "), "TXT record has not been created in zone")
+    
+    # Now delete the record
+    update = Dnsruby::Update.new("validation-test-servers.nominet.org.uk")
+    update.present(update_name, 'TXT')
+    update.delete(update_name)
+    tsig = Dnsruby::RR.create({
+        :type => 'TSIG', :klass => 'ANY',
+        :name        => KEY_NAME,
+        :key         => KEY
+      })
+    tsig.apply(update)
+    assert(update.signed?, "Update has not been signed")
+    res.dnssec=false # Or else we needed to add OPT record already
+    res.udp_size = 512
+    response = res.send_message(update)
+    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert(response.verified?, "Response has not been verified")
+    
+    # Now check the record does not exist
+    begin
+      rr = res.query(update_name, 'TXT')
+      assert(false)
+    rescue Dnsruby::NXDomain
+    end
+  end
+  
+  def test_message_signing
+    m = Dnsruby::Message.new("example.com")
+    m.set_tsig("name", "key")
+    assert(!m.signed?)
+    m.encode
+    assert(m.signed?)
+    
+    m = Dnsruby::Message.new("example.com")
+    m.set_tsig("name", "key")
+    assert(!m.signed?)
+    m.sign!    
+    assert(m.signed?)
+    
+    m = Dnsruby::Message.new("example.com")
+    assert(!m.signed?)
+    m.sign!("name", "key")
+    assert(m.signed?)
+  end
+  
+  def test_signed_zone_transfer
+    # test TSIG over TCP session
+    axfr
+    ixfr
+  end
+  
+  def axfr
+    zt = Dnsruby::ZoneTransfer.new
+    zt.transfer_type = Dnsruby::Types.AXFR
+    zt.tsig=KEY_NAME, KEY
+    zt.server = "ns0.validation-test-servers.nominet.org.uk"
+    zone = zt.transfer("validation-test-servers.nominet.org.uk")
+    assert(zone.length > 0)
+    assert(zt.last_tsigstate==:Verified)
+  end
+  
+  # We also test IXFR here - this is because we need to update a record (using
+  # TSIG) before we can test ixfr...  
+  def ixfr
+    # Check the SOA serial, do an update, check that the IXFR for that soa serial gives us the update we did,
+    # then delete the updated record
+    start_soa_serial = get_soa_serial("validation-test-servers.nominet.org.uk")
+    
+    # Now do an update
+    res = Dnsruby::Resolver.new("ns0.validation-test-servers.nominet.org.uk")
+    res.query_timeout=10
+    res.tsig=KEY_NAME, KEY
+    
+    update = Dnsruby::Update.new("validation-test-servers.nominet.org.uk")
+    # Generate update record name, and test it has been made. Then delete it and check it has been deleted
+    update_name = Time.now.to_i.to_s + rand(100).to_s + ".update.validation-test-servers.nominet.org.uk"
+    update.absent(update_name)
+    update.add(update_name, 'TXT', 100, "test zone transfer")
+    assert(!update.signed?, "Update has been signed")
+    
+    response = res.send_message(update)
+    assert(response.header.rcode == Dnsruby::RCode.NOERROR)
+    
+    end_soa_serial = get_soa_serial("validation-test-servers.nominet.org.uk")
+    
+    zt = Dnsruby::ZoneTransfer.new
+    zt.transfer_type = Dnsruby::Types.IXFR
+    zt.server = "ns0.validation-test-servers.nominet.org.uk"
+    zt.serial = start_soa_serial # 2007090401
+    deltas = zt.transfer("validation-test-servers.nominet.org.uk")
+    assert(deltas.length > 0)
+    assert(deltas.last.class == Dnsruby::ZoneTransfer::Delta)
+    assert_equal("test zone transfer", deltas.last.adds.last.strings.join(" "))
+    assert(zt.last_tsigstate==nil)
+    
+    # Now delete the updated record
+    update = Dnsruby::Update.new("validation-test-servers.nominet.org.uk")
+    update.present(update_name, 'TXT')
+    update.delete(update_name)
+    response = res.send_message(update)
+    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+  end
+  
+  def get_soa_serial(name)
+    soa_serial = nil
+    Dnsruby::DNS.open {|dns|
+      soa_rr = dns.getresource(name, 'SOA')
+      soa_serial = soa_rr.serial
+    }
+    return soa_serial    
+  end
+end