dnsruby 1.36 → 1.37

data/lib/Dnsruby/event_machine_interface.rb

@@ -1,266 +0,0 @@
-# Support for EventMachine has been deprecated.
-#require 'eventmachine'
-#module Dnsruby
-#  class EventMachineInterface#:nodoc: all
-#    @@started_em_here = false
-#    @@running_clients=[]
-#    @@outstanding_sends = []
-#    @@em_thread=nil
-#    # We want to have one EM loop running continuously in this class.
-#    # Remember to use stop_event_loop inside of EM callback in order to stop the event machine
-#
-#    # Timers - can't use EM timers as they max out at 1000.
-#    # Instead, while queries are outstanding, call next_tick to manage our own list of timers.
-#
-#    @@timer_procs={} # timeout=>[proc
-#    @@timer_keys_sorted=[]
-#    TIMER_PERIOD = 0.1
-#
-#    def EventMachineInterface::process_timers
-#      # Go through list of timers
-#      now = Time.now
-#      @@timer_keys_sorted.each do |timeout|
-#        if (timeout > now)
-#          break
-#        end
-#        c, proc = @@timer_procs[timeout]
-#        @@timer_procs.delete(timeout)
-#        @@timer_keys_sorted.delete(timeout)
-#        proc.call
-#      end
-#
-#      if (!@@outstanding_sends.empty?)
-#        EventMachine::add_timer(TIMER_PERIOD) {process_timers}
-#      end
-#    end
-#
-#    def EventMachineInterface::remove_timer(c)
-#      # Remove from timer structures - if still there!
-#      @@timer_procs.each do |timeout, value|
-#        conn, proc = value
-#        if (c==conn)
-#          @@timer_procs.delete(timeout)
-#          @@timer_keys_sorted.delete(timeout)
-#        end
-#      end
-#    end
-#
-#    def EventMachineInterface::add_to_outstanding(c, timeout)
-#      # Add to timer structures
-#      @@timer_procs[Time.now+timeout]=[c, Proc.new {
-#          # Cancel the send
-#          c.closing=true
-#          c.close_connection
-#          c.send_timeout
-#        }]
-#      @@timer_keys_sorted=@@timer_procs.keys.sort
-#      @@outstanding_sends.push(c)
-##      puts "#{@@outstanding_sends.length} outstanding connections"
-#      if (@@outstanding_sends.length==1)
-#        EventMachine::add_timer(0) {process_timers}
-#      end
-#    end
-#
-#    def EventMachineInterface::remove_from_outstanding(c)
-#      @@outstanding_sends.delete(c)
-##      puts "#{@@outstanding_sends.length} outstanding connections"
-#      remove_timer(c)
-#      # If we explicitly started the EM loop, and there are no more outstanding sends, then stop the EM loop
-#      stop_eventmachine
-#    end
-#
-#    def EventMachineInterface::start_eventmachine
-#      if (!eventmachine_running?)
-#        if Resolver.start_eventmachine_loop?
-#          Dnsruby.log.debug("Starting EventMachine")
-#          @@started_em_here = true
-#          @@em_thread = Thread.new {
-#            EM.run {
-##              EventMachine::add_periodic_timer(0.1) {EventMachineInterface::process_timers}
-#              EventMachine::add_timer(0.1) {EventMachineInterface::process_timers}
-#              @@df = EventMachine::DefaultDeferrable.new
-#              @@df.callback{
-#                Dnsruby.log.debug("Stopping EventMachine")
-#                EM.stop
-#                @@em_thread=nil
-#              }
-#            }
-#          }
-#        else
-#          Dnsruby.log.debug("Not trying to start event loop")
-#        end
-#      end
-#    end
-#
-#    def EventMachineInterface::start_em_for_resolver(res)
-#      @@running_clients.push(res)
-#      start_eventmachine
-#    end
-#
-#    def EventMachineInterface::stop_em_for_resolver(res)
-#      @@running_clients.each_index do |i|
-#        if (@@running_clients[i]==res)
-#          @@running_clients.delete_at(i)
-#        end
-#      end
-#      stop_eventmachine
-#    end
-#
-#    def EventMachineInterface::eventmachine_running?
-#      return (@@em_thread!=nil)
-#    end
-#
-#    def EventMachineInterface::stop_eventmachine
-#      if (@@started_em_here)
-#        if (@@outstanding_sends.size==0)
-#          if (@@running_clients.length == 0)
-#            if (@@em_thread)
-#              @@df.set_deferred_status :succeeded
-#              @@started_em_here = false
-#              #              @@em_thread = nil
-#            end
-#          end
-#        end
-#      end
-#    end
-#
-#    def EventMachineInterface::send(args={})#msg, timeout, server, port, src_add, src_port, use_tcp)
-#      # Is the EventMachine loop running? If not, we need to start it (and mark that we started it)
-#      begin
-#        if (!EventMachine.reactor_running?)
-#          start_eventmachine
-#        end
-#      rescue Exception
-#        #@TODO@ EM::reactor_running? only introduced in EM v0.9.0 - if it's not there, we simply don't know what to do...
-#        Dnsruby.log.error("EventMachine::reactor_running? not available.")
-#        #        if Resolver.start_eventmachine_loop?
-#        #          Dnsruby.log.debug("Trying to start event loop - may prove fatal...")
-#        start_eventmachine
-#        #        else
-#        #          Dnsruby.log.debug("Not trying to start event loop.")
-#        #        end
-#      end
-#      df = nil
-#      if (args[:use_tcp])
-#        df = send_tcp(args)
-#      else
-#        df = send_udp(args)
-#      end
-#      # Need to add this send to the list of outstanding sends
-#      add_to_outstanding(df, args[:timeout])
-#      return df
-#    end
-#
-#    def EventMachineInterface::send_tcp(args={})#msg, timeout, server, port, src_add, src_port, use_tcp)
-#      connection = EventMachine::connect(args[:server], args[:port], EmTcpHandler) { |c|
-#        #@TODO SRC_PORT FOR TCP!!!
-#        c.timeout_time=Time.now + args[:timeout]
-#        c.instance_eval {@args = args}
-#        lenmsg = [args[:msg].length].pack('n')
-#        c.send_data(lenmsg)
-#        c.send_data args[:msg] # , args[:server], args[:port]
-#        Dnsruby.log.debug {"EventMachine : Sent TCP packet to #{args[:server]}:#{args[:port]}" + # from #{args[:src_address]}:#{args[:src_port]}, timeout=#{args[:timeout]}"
-#        ", timeout=#{args[:timeout]}"}
-#      }
-#      return connection # allows clients to set callback, errback, etc., if desired
-#    end
-#
-#    def EventMachineInterface::send_udp(args={})# msg, timeout, server, port, src_add, src_port, use_tcp)
-#      connection = EventMachine::open_datagram_socket(args[:src_address], args[:src_port], EmUdpHandler) { |c|
-#        c.timeout_time=Time.now + args[:timeout]
-#        c.instance_eval {@args = args}
-#        c.send_datagram args[:msg], args[:server], args[:port]
-#        Dnsruby.log.debug{"EventMachine : Sent datagram to #{args[:server]}:#{args[:port]} from #{args[:src_address]}:#{args[:src_port]}, timeout=#{args[:timeout]}"}
-#      }
-#      return connection # allows clients to set callback, errback, etc., if desired
-#    end
-#
-#
-#    class EmUdpHandler < EventMachine::Connection #:nodoc: all
-#      include EM::Deferrable
-#      attr_accessor :closing, :timeout_time
-#      def post_init
-#        @closing=false
-#      end
-#      def receive_data(dgm)
-#        Dnsruby.log.debug{"UDP receive_data called"}
-#        process_incoming_message(dgm)
-#      end
-#
-#      def process_incoming_message(data)
-#        Dnsruby.log.debug{"Processing incoming message, #{data.length} bytes"}
-#        ans=nil
-#        begin
-#          ans = Message.decode(data)
-#        rescue Exception => e
-#          Dnsruby.log.error{"Decode error! #{e.class}, #{e}\nfor msg (length=#{data.length}) : #{data}"}
-#          @closing=true
-#          close_connection
-#          send_to_client(nil, nil, e)
-#          return
-#        end
-#        Dnsruby.log.debug{"#{ans}"}
-#        ans.answerfrom=(@args[:server])
-#        ans.answersize=(data.length)
-#        exception = ans.header.get_exception
-#        @closing=true
-#        close_connection
-#        send_to_client(ans, data, exception)
-#      end
-#
-#      def unbind
-#        Dnsruby.log.debug{"Unbind called"}
-#        if (!@closing)
-#          if (@timeout_time <= Time.now + 1)
-#            send_timeout
-#          else
-#            Dnsruby.log.debug{"Sending IOError to client"}
-#            send_to_client(nil, nil, IOError.new("Network error"))
-#          end
-#        end
-#        @closing=false
-#        # Take the last send off the list of outstanding sends
-#        EventMachineInterface.remove_from_outstanding(self)
-#      end
-#      def send_timeout
-#        Dnsruby.log.debug{"Sending timeout to client"}
-#        send_to_client(nil, nil, ResolvTimeout.new("Query timed out"))
-#      end
-#      def send_to_client(msg, bytes, err)
-#        #  We call set_defered_status when done
-#        if (err != nil)
-#          set_deferred_status :failed, msg, err
-#        else
-#          set_deferred_status :succeeded, msg, bytes
-#        end
-#      end
-#    end
-#
-#
-#    class EmTcpHandler < EmUdpHandler #:nodoc: all
-#      def post_init
-#        super
-#        @data=""
-#        @answersize = 0
-#      end
-#      def receive_data(data)
-#        Dnsruby.log.debug{"TCP receive_data called"}
-#        #Buffer up the incoming data until we have a complete packet
-#        @data << data
-#        if (@data.length >= 2)
-#          if (@answersize == 0)
-#            @answersize = @data[0..1].unpack('n')[0]
-#            Dnsruby.log.debug{"TCP - expecting #{@answersize} bytes"}
-#          end
-#          if (@answersize == @data.length - 2)
-#            Dnsruby.log.debug{"TCP - got all #{@answersize} bytes "}
-#            process_incoming_message(@data[2..@data.length])
-#          else
-#            Dnsruby.log.debug{"TCP - got #{@data.length-2} message bytes"}
-#          end
-#        end
-#      end
-#    end
-#
-#  end
-#end

data/test/tc_event_machine_deferrable.rb

@@ -1,85 +0,0 @@
-$:.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.log.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

@@ -1,174 +0,0 @@
-$:.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.log.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.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

@@ -1,101 +0,0 @@
-$:.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.log.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