dnsruby 1.26 → 1.30

data/lib/Dnsruby/Resolver.rb

@@ -13,12 +13,14 @@
 #See the License for the specific language governing permissions and 
 #limitations under the License.
 #++
-require "Dnsruby/SingleResolver"
+#require "Dnsruby/resolver_register.rb"
+require "Dnsruby/PacketSender"
 require "Dnsruby/Recursor"
 module Dnsruby
   #== Description
   #Dnsruby::Resolver is a DNS stub resolver.
-  #This class uses a set of SingleResolvers to perform queries with retries across multiple nameservers.
+  #This class performs queries with retries across multiple nameservers.
+  #The system configured resolvers are used by default.
   #
   #The retry policy is a combination of the Net::DNS and dnsjava approach, and has the option of :
   #* A total timeout for the query (defaults to 0, meaning "no total timeout")
@@ -31,6 +33,14 @@ module Dnsruby
   #  
   # Note also that these timeouts are distinct from the SingleResolver's packet_timeout
   #
+  # Timeouts apply to the initial query and response. If DNSSEC validation is to
+  # be performed, then additional queries may be required (these are performed automatically
+  # by Dnsruby). Each additional query will be performed with its own timeouts.
+  # So, even with a query_timeout of 5 seconds, a response which required extensive
+  # validation may take several times that long.
+  # (Future versions of Dnsruby may expose finer-grained events for client tracking of
+  # responses and validation)
+  #
   #== Methods
   # 
   #=== Synchronous
@@ -46,29 +56,24 @@ module Dnsruby
   #
   #== Event Loop
   #Dnsruby runs a pure Ruby event loop to handle I/O in a single thread.
-  #It is also possible to configure Dnsruby to use EventMachine instead.
-  #See the Dnsruby::Resolver::use_eventmachine method for details.
-  #
-  #Note that, if using Dnsruby from an EventMachine loop, you will need to tell
-  #Dnsruby not to start the event loop itself :
-  #
-  #   Dnsruby::Resolver::use_eventmachine(true)
-  #   Dnsruby::Resolver::start_eventmachine_loop(false)
+  #Support for EventMachine has been deprecated.
   class Resolver
-    @@event_machine_available=false
-    begin
-      require 'Dnsruby/event_machine_interface'
-      @@event_machine_available=true
-      Dnsruby.log.debug{"EventMachine loaded"}
-    rescue LoadError
-      Dnsruby.log.error{"EventMachine not found"}
-    end
     DefaultQueryTimeout = 0 
     DefaultPacketTimeout = 10
     DefaultRetryTimes = 4
     DefaultRetryDelay = 5
     DefaultPort = 53
-    DefaultUDPSize = 512
+    DefaultDnssec = true
+    AbsoluteMinDnssecUdpSize = 1220
+    MinDnssecUdpSize = 4096
+    DefaultUDPSize = MinDnssecUdpSize
+
+    class EventType
+      RECEIVED = 0 
+      VALIDATED = 1 # @TODO@ Should be COMPLETE?
+      ERROR = 2
+    end
+
     # The port to send queries to on the resolver
     attr_reader :port
     
@@ -85,11 +90,6 @@ module Dnsruby
     # The source address to send queries from
     attr_reader :src_address
     
-    # Should TCP queries be sent on a persistent socket?
-    attr_reader :persistent_tcp
-    # Should UDP queries be sent on a persistent socket?
-    attr_reader :persistent_udp
-    
     # Should the Recursion Desired bit be set?
     attr_reader :recurse
     
@@ -100,7 +100,19 @@ module Dnsruby
     attr_reader :config
     
     # The array of SingleResolvers used for sending query messages
-    attr_reader :single_resolvers
+    #    attr_accessor :single_resolvers # :nodoc:
+    def single_resolvers=(s) # :nodoc:
+      @configured = true
+#      @single_res_mutex.synchronize {
+      @single_resolvers = s
+#      }
+    end
+    def single_resolvers # :nodoc:
+      if (!@configured)
+        add_config_nameservers
+      end
+      return @single_resolvers
+    end
     
     #The timeout for any individual packet. This is the timeout used by SingleResolver
     attr_reader :packet_timeout
@@ -119,15 +131,21 @@ module Dnsruby
     
     # Use DNSSEC for this Resolver
     attr_reader :dnssec
-    
-    @@use_eventmachine=false
-    @@start_eventmachine_loop=true
+
+    # Defines whether validation is performed by default on this Resolver when the
+    # query method is called.
+    # Note that send_message and send_async expect a
+    # Message object to be passed in, which is already configured to the callers
+    # requirements.
+    attr_accessor :do_validation
     
     #--
     #@TODO@ add load_balance? i.e. Target nameservers in a random, rather than pre-determined, order?
+    #This is best done when configuring the Resolver, as it will re-order servers based on their response times.
+    #
     #++
     
-    # Query for a n. If a valid Message is received, then it is returned 
+    # Query for a name. If a valid Message is received, then it is returned
     # to the caller. Otherwise an exception (a Dnsruby::ResolvError or Dnsruby::ResolvTimeout) is raised.
     #
     #   require 'Dnsruby'
@@ -140,11 +158,23 @@ module Dnsruby
       msg = Message.new
       msg.header.rd = 1
       msg.add_question(name, type, klass)
+      msg.do_validation = @do_validation
       if (@dnssec)
         msg.header.cd = set_cd # We do our own validation by default
       end
       return send_message(msg)
     end
+
+    def query_no_validation_or_recursion(name, type=Types.A, klass=Classes.IN) # :nodoc: all
+      msg = Message.new
+      msg.header.rd = false
+      msg.do_validation = false
+      msg.add_question(name, type, klass)
+      if (@dnssec)
+        msg.header.cd = true # We do our own validation by default
+      end
+      return send_message(msg)
+    end
     
     # Send a message, and wait for the response. If a valid Message is received, then it is returned 
     # to the caller. Otherwise an exception (a Dnsruby::ResolvError or Dnsruby::ResolvTimeout) is raised.
@@ -153,7 +183,8 @@ module Dnsruby
     # 
     # example :
     # 
-    #   require 'Dnsruby'
+    #   require 'dnsruby'
+    #   include Dnsruby
     #   res = Dnsruby::Resolver.new
     #   begin
     #   response = res.send_message(Message.new("example.com", Types.MX))
@@ -166,18 +197,69 @@ module Dnsruby
       Dnsruby.log.debug{"Resolver : sending message"}
       q = Queue.new
       send_async(message, q)
+      #      # @TODO@ Add new queue tuples, e.g. :
+      #      event_type = EventType::RECEIVED
+      #      reply = nil
+      #      while (event_type == EventType::RECEIVED)
+      #        id, event_type, reply, error = q.pop
+      #        Dnsruby.log.debug{"Resolver : result received"}
+      #        if ((error != nil) && (event_type == EventType::ERROR))
+      #          raise error
+      #        end
+      #        print "Reply = #{reply}\n"
+      #      end
+      #      print "Reply = #{reply}\n"
+      #      return reply
+
       id, result, error = q.pop
-      Dnsruby.log.debug{"Resolver : result received"}
+
       if (error != nil)
         raise error
       else
         return result
       end
     end
+
+    # This method takes a Message (supplied by the client), and sends it to
+    # the configured nameservers. No changes are made to the Message before it
+    # is sent (TSIG signatures will be applied if configured on the Resolver).
+    # Retries are handled as the Resolver is configured to do.
+    # Incoming responses to the query are not cached or validated (although TCP
+    # fallback will be performed if the TC bit is set and the (Single)Resolver has
+    # ignore_truncation set to false).
+    # Note that the Message is left untouched - this means that no OPT records are
+    # added, even if the UDP transport for the server is specified at more than 512
+    # bytes. If it is desired to use EDNS for this packet, then you should call
+    # the Dnsruby::PacketSender#prepare_for_dnssec(msg), or
+    # Dnsruby::PacketSender#add_opt_rr(msg)
+    # The return value from this method is the [response, error] tuple. Either of
+    # these values may be nil - it is up to the client to check.
+    #
+    # example :
+    #
+    #   require 'dnsruby'
+    #   include Dnsruby
+    #   res = Dnsruby::Resolver.new
+    #   response, error = res.send_plain_message(Message.new("example.com", Types.MX))
+    #   if (error)
+    #     print "Error returned : #{error}\n"
+    #   else
+    #     process_response(response)
+    #   end
+    def send_plain_message(message)
+      Dnsruby::TheLog.debug("Resolver : send_plain_message")
+      message.do_caching = false
+      message.do_validation = false
+      message.send_raw = true
+      q = Queue.new
+      send_async(message, q)
+      id, result, error = q.pop
+      return [result, error]
+    end
     
     
     #Asynchronously send a Message to the server. The send can be done using just
-    #Dnsruby, or using EventMachine.
+    #Dnsruby. Support for EventMachine has been deprecated.
     # 
     #== Dnsruby pure Ruby event loop :
     # 
@@ -229,75 +311,23 @@ module Dnsruby
     #     end
     #   end
     #
-    #== If EventMachine is being used :
-    # 
-    #If EventMachine is being used (see Dnsruby::Resolver::use_eventmachine, then this method returns
-    #an EM::Deferrable object. When the response is known, then the Deferrable will complete.
-    #If a queue (and ID) is passed in, then the response will also be 
-    #pushed to the Queue. Note that an ID is not automatically generated by this version.
-    # 
-    #=== Example invocations :
-    #
-    #    deferrable = res.send_async(msg)
-    #    deferrable = res.send_async(msg, use_tcp)
-    #    deferrable = res.send_async(msg, q, id, use_tcp)
-    #    
-    #=== Example code  
-    #* Here is an example of using the code in an EventMachine style :
-    #
-    #    require 'Dnsruby'
-    #    require 'eventmachine'
-    #    res = Dnsruby::Resolver.new
-    #    Dnsruby::Resolver.use_eventmachine
-    #    Dnsruby::Resolver.start_eventmachine_loop(false)
-    #    EventMachine::run {
-    #      df = res.send_async(Dnsruby::Message.new("example.com"))
-    #      df.callback {|msg|
-    #         puts "Response : #{msg}"
-    #         EM.stop}
-    #      df.errback {|msg, err|
-    #         puts "Response : #{msg}"
-    #         puts "Error: #{err}"
-    #         EM.stop}
-    #    }
-    #
-    #* And an example in a normal Dnsruby style :
-    #
-    #    require 'Dnsruby'
-    #    res = Dnsruby::Resolver.new
-    #    Dnsruby::Resolver.use_eventmachine
-    #    Dnsruby::Resolver.start_eventmachine_loop(true) # default
-    #    q = Queue.new
-    #    id = res.send_async(Dnsruby::Message.new("example.com"),q)
-    #    id, response, error = q.pop
-    #
     def send_async(*args) # msg, client_queue, client_query_id)
-      if (Resolver.eventmachine?)
-        if (!@resolver_em)
-          @resolver_em = ResolverEM.new(self)
-        end
-        return @resolver_em.send_async(*args)
-      else
-        if (!@resolver_ruby) # @TODO@ Synchronize this?
-          @resolver_ruby = ResolverRuby.new(self)
-        end
-        return @resolver_ruby.send_async(*args)
+      if (!@configured)
+        add_config_nameservers
+      end
+#      @single_res_mutex.synchronize {
+      if (!@resolver_ruby) # @TODO@ Synchronize this?
+        @resolver_ruby = ResolverRuby.new(self)
       end
+#      }
+      return @resolver_ruby.send_async(*args)
     end
     
     # Close the Resolver. Unfinished queries are terminated with OtherResolvError.
     def close
-      [@resolver_em, @resolver_ruby].each do |r| r.close if r end
+      @resolver_ruby.close if @resolver_ruby
     end
     
-#    def make_query(*args)
-#      return @single_resolvers[0].make_query(*args)
-#    end
-#
-#    def make_query_packet(args)
-#      return @single_resolvers[0].make_query_packet(args)
-#    end
-#
     # Create a new Resolver object. If no parameters are passed in, then the default 
     # system configuration will be used. Otherwise, a Hash may be passed in with the 
     # following optional elements : 
@@ -309,8 +339,6 @@ module Dnsruby
     # * :ignore_truncation
     # * :src_address
     # * :src_port
-    # * :persistent_tcp
-    # * :persistent_udp
     # * :recurse
     # * :udp_size
     # * :config_info - see Config
@@ -320,9 +348,12 @@ module Dnsruby
     # * :retry_times
     # * :retry_delay
     def initialize(*args)
-      @resolver_em = nil
+      # @TODO@ Should we allow :namesver to be an RRSet of NS records? Would then need to randomly order them?
       @resolver_ruby = nil
       @src_address = nil
+      @single_res_mutex = Mutex.new
+      @configured = false
+      @config = Config.new()
       reset_attributes
       
       # Process args
@@ -350,46 +381,58 @@ module Dnsruby
       else
         # Anything to do?
       end
-      if (@single_resolvers==[])
-        add_config_nameservers
-      end
+      #      if (@single_resolvers==[])
+      #        add_config_nameservers
+      #      end
       update
+      #      ResolverRegister::register_resolver(self)
     end
     
-    def add_config_nameservers
+    def add_config_nameservers # :nodoc: all
+      if (!@configured)
+        @config.get_ready
+      end
+      @configured = true
+      @single_res_mutex.synchronize {
       # Add the Config nameservers
       @config.nameserver.each do |ns|
-        @single_resolvers.push(SingleResolver.new({:server=>ns, :dnssec=>@dnssec,
-            :use_tcp=>@use_tcp, :packet_timeout=>@packet_timeout,
-          :tsig => @tsig, :ignore_truncation=>@ignore_truncation,
-         :src_address=>@src_address, :src_port=>@src_port, 
-         :recurse=>@recurse, :udp_size=>@udp_size}))
+        @single_resolvers.push(PacketSender.new({:server=>ns, :dnssec=>@dnssec,
+              :use_tcp=>@use_tcp, :packet_timeout=>@packet_timeout,
+              :tsig => @tsig, :ignore_truncation=>@ignore_truncation,
+              :src_address=>@src_address, :src_port=>@src_port,
+              :recurse=>@recurse, :udp_size=>@udp_size}))
       end
+      }
     end
     
     def set_config_nameserver(n)
+      # @TODO@ Should we allow NS RRSet here? If so, then .sort_by {rand}
+      if (!@configured)
+        @config.get_ready
+      end
+      @configured = true
       if (n).kind_of?String
         @config.nameserver=[n]
       else
         @config.nameserver=n
       end
+      add_config_nameservers
     end    
     
     def reset_attributes #:nodoc: all
-      if (@resolver_em)
-        @resolver_em.reset_attributes
-      end
       if (@resolver_ruby)
         @resolver_ruby.reset_attributes
       end
      
       # Attributes
+      @do_validation = true
       @query_timeout = DefaultQueryTimeout
       @retry_delay = DefaultRetryDelay
       @retry_times = DefaultRetryTimes
       @packet_timeout = DefaultPacketTimeout
       @port = DefaultPort
       @udp_size = DefaultUDPSize
+      @dnssec = DefaultDnssec
       @use_tcp = false
       @tsig = nil
       @ignore_truncation = false
@@ -397,32 +440,51 @@ module Dnsruby
       @src_address        = '0.0.0.0'
       @src_port        = [0]
       @recurse = true
-      @persistent_udp = false
-      @persistent_tcp = false
+      @single_res_mutex.synchronize {
       @single_resolvers=[]
-      @dnssec = SingleResolver::DEFAULT_DNSSEC
+      }
+      @configured = false
     end
     
     def update #:nodoc: all
       #Update any resolvers we have with the latest config
-      @single_resolvers.each do |res|
-        [:port, :use_tcp, :tsig, :ignore_truncation, :packet_timeout, 
-          :src_address, :src_port, :persistent_tcp, :persistent_udp, :recurse, 
-          :udp_size, :dnssec].each do |param|
-          
-          res.send(param.to_s+"=", instance_variable_get("@"+param.to_s))
+      @single_res_mutex.synchronize {
+        @single_resolvers.each do |res|
+          update_internal_res(res)
         end
-      end
+      }
     end
     
-    # Add a new SingleResolver to the list of resolvers this Resolver object will 
-    # query.
-    def add_resolver(single)
-      @single_resolvers.push(single)
+    #    # Add a new SingleResolver to the list of resolvers this Resolver object will
+    #    # query.
+    #    def add_resolver(internal) # :nodoc:
+    #      # @TODO@ Make a new PacketSender from this SingleResolver!!
+    #      @single_resolvers.push(internal)
+    #    end
+
+    def add_server(server)# :nodoc:
+      @configured = true
+      res = PacketSender.new(server)
+      update_internal_res(res)
+      @single_res_mutex.synchronize {
+        @single_resolvers.push(res)
+      }
+    end
+
+    def update_internal_res(res)
+      [:port, :use_tcp, :tsig, :ignore_truncation, :packet_timeout,
+        :src_address, :src_port, :recurse,
+        :udp_size, :dnssec].each do |param|
+
+        res.send(param.to_s+"=", instance_variable_get("@"+param.to_s))
+      end
     end
     
     def nameserver=(n)
+      @configured = true
+            @single_res_mutex.synchronize {
       @single_resolvers=[]
+            }
       set_config_nameserver(n)
       add_config_nameservers
     end
@@ -458,8 +520,8 @@ module Dnsruby
     #        res.src_port=60015..60115
     #
     def src_port=(p)
-      if (SingleResolver.check_port(p))
-        @src_port = SingleResolver.get_ports_from(p)
+      if (Resolver.check_port(p))
+        @src_port = Resolver.get_ports_from(p)
         update
       end
     end
@@ -477,8 +539,8 @@ module Dnsruby
     #        res.add_src_port(60015..60115)
     #
     def add_src_port(p)
-      if (SingleResolver.check_port(p, @src_port))
-        a = SingleResolver.get_ports_from(p)
+      if (Resolver.check_port(p, @src_port))
+        a = Resolver.get_ports_from(p)
         a.each do |x|
           if ((@src_port.length > 0) && (x == 0))
             raise ArgumentError.new("src_port of 0 only allowed as only src_port value (currently #{@src_port.length} values")
@@ -489,6 +551,48 @@ module Dnsruby
       update
     end
 
+    def Resolver.check_port(p, src_port=[])
+      if (p.class != Fixnum)
+        tmp_src_ports = Array.new(src_port)
+        p.each do |x|
+          if (!Resolver.check_port(x, tmp_src_ports))
+            return false
+          end
+          tmp_src_ports.push(x)
+        end
+        return true
+      end
+      if (Resolver.port_in_range(p))
+        if ((p == 0) && (src_port.length > 0))
+          return false
+        end
+        return true
+      else
+        Dnsruby.log.error("Illegal port (#{p})")
+        raise ArgumentError.new("Illegal port #{p}")
+      end
+    end
+
+    def Resolver.port_in_range(p)
+      if ((p == 0) || ((IANA_PORTS.index(p)) == nil &&
+              (p > 1024) && (p < 65535)))
+        return true
+      end
+      return false
+    end
+
+    def Resolver.get_ports_from(p)
+      a = []
+      if (p.class == Fixnum)
+        a = [p]
+      else
+        p.each do |x|
+          a.push(x)
+        end
+      end
+      return a
+    end
+
     def use_tcp=(on)
       @use_tcp = on
       update
@@ -504,6 +608,29 @@ module Dnsruby
       @tsig=t
       update
     end
+
+    def Resolver.get_tsig(args)
+      tsig = nil
+      if (args.length == 1)
+        if (args[0])
+          if (args[0].instance_of?RR::TSIG)
+            tsig = args[0]
+          elsif (args[0].instance_of?Array)
+            tsig = RR.new_from_hash({:type => Types.TSIG, :klass => Classes.ANY, :name => args[0][0], :key => args[0][1]})
+          end
+        else
+          #          Dnsruby.log.debug{"TSIG signing switched off"}
+          return nil
+        end
+      elsif (args.length ==2)
+        tsig = RR.new_from_hash({:type => Types.TSIG, :klass => Classes.ANY, :name => args[0], :key => args[1]})
+      else
+        raise ArgumentError.new("Wrong number of arguments to tsig=")
+      end
+      Dnsruby.log.info{"TSIG signing now using #{tsig.name}, key=#{tsig.key}"}
+      return tsig
+    end
+
     
     def ignore_truncation=(on)
       @ignore_truncation = on
@@ -537,6 +664,12 @@ module Dnsruby
     
     def dnssec=(d)
       @dnssec = d
+      if (d)
+        # Set the UDP size (RFC 4035 section 4.1)
+        if (@udp_size < MinDnssecUdpSize)
+          self.udp_size = MinDnssecUdpSize
+        end
+      end
       update
     end
     
@@ -544,262 +677,46 @@ module Dnsruby
       @udp_size = s
       update
     end
-    #Tell Dnsruby to use EventMachine for I/O. 
-    #
-    #If EventMachine is not used, then the pure Ruby event loop in Dnsruby will
-    #be used instead.
-    #
-    #If EventMachine is not available on the platform, then a RuntimeError will be raised.
-    #
-    #Takes a bool to say whether or not to use EventMachine.
-    def Resolver.use_eventmachine(on=true)
-      if (on && !@@event_machine_available)
-        raise RuntimeError.new("EventMachine is not available in this environment!")
-      end
-      @@use_eventmachine = on
-      if (on)
-        Dnsruby.log.info{"EventMachine will be used for IO"}
-      else
-        Dnsruby.log.info{"EventMachine will not be used for IO"}
-      end
-    end
-    #Check whether EventMachine will be used by Dnsruby
-    def Resolver.eventmachine?
-      return @@use_eventmachine
-    end
-    #If EventMachine is being used, then this method tells Dnsruby whether or not
-    #to start the EventMachine loop. If you want to use Dnsruby client code as 
-    #is, but using EventMachine for I/O, then Dnsruby must start the EventMachine
-    #loop for you. This is the default behaviour.
-    #If you want to use EventMachine-style code, where everything is wrapped
-    #up in an EventMachine::run{} call, then this method should be called with
-    #false as the parameter.
-    #
-    #Takes a bool argument to say whether or not to start the event loop when required.
-    def Resolver.start_eventmachine_loop(on=true)
-      @@start_eventmachine_loop=on
-      if (on)
-        Dnsruby.log.info{"EventMachine loop will be started by Dnsruby"}
-      else
-        Dnsruby.log.info{"EventMachine loop will not be started by Dnsruby"}
-      end
-    end
-    #Checks whether Dnsruby will start the EventMachine loop when required.
-    def Resolver.start_eventmachine_loop?
-      return @@start_eventmachine_loop
+
+    def single_res_mutex # :nodoc: all
+      return @single_res_mutex
     end
+
     def generate_timeouts(base=0) #:nodoc: all
       #These should be be pegged to the single_resolver they are targetting :
       #  e.g. timeouts[timeout1]=nameserver
       timeouts = {}
       retry_delay = @retry_delay
-      @retry_times.times do |retry_count|
-        if (retry_count>0)
-          retry_delay *= 2
-        end
-        servers=[]
-        @single_resolvers.each do |r| servers.push(r.server) end
-        @single_resolvers.each_index do |i|
-          res= @single_resolvers[i]
-          offset = (i*@retry_delay.to_f/@single_resolvers.length)
-          if (retry_count==0)
-            timeouts[base+offset]=[res, retry_count]
-          else
-            if (timeouts.has_key?(base+retry_delay+offset))
-              Dnsruby.log.error{"Duplicate timeout key!"}
-              raise RuntimeError.new("Duplicate timeout key!")
-            end
-            timeouts[base+retry_delay+offset]=[res, retry_count]
+#      @single_res_mutex.synchronize {
+        @retry_times.times do |retry_count|
+          if (retry_count>0)
+            retry_delay *= 2
           end
-        end
-      end
-      return timeouts      
-    end
-  end
-  
-  # This class implements the I/O using EventMachine.
-  # This is the preferred implementation. 
-  # NOTE - EM does not work properly on Windows with version 0.8.1 - do not use!
-  class ResolverEM #:nodoc: all
-    TIMER_PERIOD = 0.1
-    def initialize(parent)
-      @parent=parent
-    end
-    def reset_attributes #:nodoc: all
-    end
-    class PersistentData
-      attr_accessor :outstanding, :deferrable, :to_send, :timeouts, :timer_procs, :timer_keys_sorted, :finish
-    end
-    def send_async(*args) #msg, client_queue=nil, client_query_id=nil)
-      msg=args[0]
-      client_queue=nil
-      client_query_id=nil
-      if (args.length>1)
-        client_queue=args[1]
-        if (args.length > 2)
-          client_query_id = args[2]
-        end
-      end
-      # We want to send the query to the first resolver.
-      # We then want to set up all the timers for all of the events which might happen
-      #   (first round timers, retry timers, etc.)
-      # The callbacks for these should be able to cancel any of the rest (including any for broken resolvers)
-      # We can then forget about the query, as all the callbacks will be lodged with EventMachine.
-      
-      EventMachineInterface::start_em_for_resolver(self)
-      persistent_data = PersistentData.new
-      persistent_data.deferrable = EM::DefaultDeferrable.new
-      persistent_data.outstanding = []
-      persistent_data.to_send = 0
-      persistent_data.timeouts=@parent.generate_timeouts(Time.now)
-      persistent_data.timer_procs = {}
-      persistent_data.finish = false
-      persistent_data.timeouts.keys.sort.each do |timeout|
-        value = persistent_data.timeouts[timeout]
-        #        timeout = timeout.round
-        single_resolver, retry_count = value
-        persistent_data.to_send+=1
-        df = nil
-        if (timeout == 0) 
-          # Send immediately
-          Dnsruby.log.debug{"Sending first EM query"}
-          df = send_new_em_query(single_resolver, msg, client_queue, client_query_id, persistent_data)
-          persistent_data.outstanding.push(df)
-        else
-          # Send later
-          persistent_data.timer_procs[timeout]=Proc.new{
-            Dnsruby.log.debug{"Sending #{timeout} delayed EM query"}
-            df = send_new_em_query(single_resolver, msg, client_queue, client_query_id, persistent_data)
-            persistent_data.outstanding.push(df)
-          }
-        end
-      end
-      query_timeout = @parent.query_timeout
-      if (query_timeout > 0)
-        persistent_data.timer_procs[Time.now+query_timeout]=Proc.new{
-          cancel_queries(persistent_data)
-          return_to_client(persistent_data.deferrable, client_queue, client_query_id, nil, ResolvTimeout.new("Query timed out after query_timeout=#{query_timeout.round} seconds"))
-        }
-      end
-      persistent_data.timer_keys_sorted = persistent_data.timer_procs.keys.sort
-      EventMachine::add_timer(0) {process_eventmachine_timers(persistent_data)}
-      return persistent_data.deferrable
-    end
-    
-    # Close the Resolver. Unfinished queries are terminated with OtherResolvError.
-    def close
-      # @TODO@ We need a list of open deferrables so that we can complete them
-    end
-    
-    def process_eventmachine_timers(persistent_data)
-      if (persistent_data.finish)
-        return
-      end
-      now = Time.now
-      persistent_data.timer_keys_sorted.each do |timeout|
-        if (timeout > now)
-          break
-        end
-        persistent_data.timer_procs[timeout].call
-        persistent_data.timer_procs.delete(timeout)
-        persistent_data.timer_keys_sorted.delete(timeout)
-      end
-      EventMachine::add_timer(TIMER_PERIOD) {process_eventmachine_timers(persistent_data)}
-    end
-    
-    def send_new_em_query(single_resolver, msg, client_queue, client_query_id, persistent_data)
-      # Pick a new QID here
-      new_msg = msg.dup();
-      new_msg.header = msg.header.dup();
-      new_msg.header.id = rand(65535);
-      df = single_resolver.send_async(new_msg) # client_queue, client_query_id)
-      persistent_data.to_send-=1
-      df.callback { |answer|
-        Dnsruby.log.debug{"Response returned"}
-        persistent_data.outstanding.delete(df)
-        cancel_queries(persistent_data)
-        return_to_client(persistent_data.deferrable, client_queue, client_query_id, answer, nil)
-      }  
-      df.errback { |response, error|
-        Dnsruby.log.debug{"Error #{error} returned"}
-        persistent_data.outstanding.delete(df)
-        if (response!="cancelling")
-
-          if (error.kind_of?(ResolvTimeout))
-            #   - if it was a timeout, then check which number it was, and how many retries are expected on that server
-            #       - if it was the last retry, on the last server, then return a timeout to the client (and clean up)
-            #       - otherwise, continue
-            # Do we have any more packets to send to this resolver?
-            if (persistent_data.outstanding.empty? && persistent_data.to_send==0)
-              Dnsruby.log.debug{"Sending timeout to client"}
-              return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
-            end
-          elsif (error.kind_of?NXDomain)
-            #   - if it was an NXDomain, then return that to the client, and stop all new queries (and clean up)
-            Dnsruby.log.debug{"NXDomain - returning to client"}
-            cancel_queries(persistent_data)
-            return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
-          elsif (error.kind_of?FormErr)
-            #   - if it was a FormErr, then return that to the client, and stop all new queries (and clean up)
-            Dnsruby.log.debug{"FormErr - returning to client"}
-            cancel_queries(persistent_data)
-            return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
-          else
-            #   - if it was any other error, then remove that server from the list for that query
-            #   If a Too Many Open Files error, then don't remove, but let retry work.
-            if (!(error.to_s=~/Errno::EMFILE/))
-              remove_server(single_resolver, persistent_data)
-              Dnsruby.log.debug{"Removing #{single_resolver.server} from resolver list for this query"}
+#          servers=[]
+#          @single_resolvers.each do |r| servers.push(r.server) end
+          @single_resolvers.each_index do |i|
+            res= @single_resolvers[i]
+            next if !res # @TODO@ WHY?1
+            offset = (i*@retry_delay.to_f/@single_resolvers.length)
+            if (retry_count==0)
+              timeouts[base+offset]=[res, retry_count]
             else
-              Dnsruby.log.debug{"NOT Removing #{single_resolver.server} due to Errno::EMFILE"}
-            end
-            #        - if it was the last server, then return an error to the client (and clean up)
-            if (persistent_data.outstanding.empty? && persistent_data.to_send==0)
-              #          if (outstanding.empty?)
-              Dnsruby.log.debug{"Sending error to client"}
-              return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
+              if (timeouts.has_key?(base+retry_delay+offset))
+                Dnsruby.log.error{"Duplicate timeout key!"}
+                raise RuntimeError.new("Duplicate timeout key!")
+              end
+              timeouts[base+retry_delay+offset]=[res, retry_count]
             end
           end
         end
-      }  
-      return df
-    end
-    
-    def remove_server(server, persistent_data)
-      # Go through persistent_data.timeouts and check all the values for that resolver
-      persistent_data.timeouts.each do |key, value|
-        if (value[0] == server)
-          # Remove the server from the list
-          persistent_data.timer_procs.delete(key)
-          persistent_data.timer_keys_sorted.delete(key)
-        end
-      end      
-    end
-    
-    def cancel_queries(persistent_data)
-      Dnsruby.log.debug{"Cancelling EM queries"}
-      persistent_data.outstanding.each do |df|
-        df.set_deferred_status :failed, "cancelling", "cancelling"
-      end
-      # Cancel the next tick
-      persistent_data.finish = true
-    end
-    
-    def return_to_client(deferrable, client_queue, client_query_id, answer, error)
-      if (client_queue)
-        client_queue.push([client_query_id, answer, error])
-      end
-      #  We call set_defered_status when done
-      if (error != nil)
-        deferrable.set_deferred_status :failed, answer, error
-      else
-        deferrable.set_deferred_status :succeeded, answer
-      end
-      EventMachineInterface::stop_em_for_resolver(self)
+#      }
+      return timeouts      
     end
   end
+  
 
   # This class implements the I/O using pure Ruby, with no dependencies.
+  # Support for EventMachine has been deprecated.
   class ResolverRuby #:nodoc: all
     def initialize(parent)
       reset_attributes
@@ -807,7 +724,7 @@ module Dnsruby
     end
     def reset_attributes #:nodoc: all
       # data structures
-      @mutex=Mutex.new
+#      @mutex=Mutex.new
       @query_list = {}
       @timeouts = {}
     end
@@ -837,22 +754,26 @@ module Dnsruby
       
       if (!client_queue.kind_of?Queue)
         Dnsruby.log.error{"Wrong type for client_queue in Resolver#send_async"}
+        # @TODO@ Handle different queue tuples - push this to generic send_error method
         client_queue.push([client_query_id, ArgumentError.new("Wrong type of client_queue passed to Dnsruby::Resolver#send_async - should have been Queue, was #{client_queue.class}")])
         return
       end
       
       if (!msg.kind_of?Message)
         Dnsruby.log.error{"Wrong type for msg in Resolver#send_async"}
+        # @TODO@ Handle different queue tuples - push this to generic send_error method
         client_queue.push([client_query_id, ArgumentError.new("Wrong type of msg passed to Dnsruby::Resolver#send_async - should have been Message, was #{msg.class}")])
         return
       end
       
       tick_needed=false
       # add to our data structures
-      @mutex.synchronize{
+#      @mutex.synchronize{
+      @parent.single_res_mutex.synchronize {
         tick_needed = true if @query_list.empty?
         if (@query_list.has_key?client_query_id)
           Dnsruby.log.error{"Duplicate query id requested (#{client_query_id}"}
+          # @TODO@ Handle different queue tuples - push this to generic send_error method
           client_queue.push([client_query_id, ArgumentError.new("Client query ID already in use")])
           return
         end
@@ -887,7 +808,8 @@ module Dnsruby
     
     # Close the Resolver. Unfinished queries are terminated with OtherResolvError.
     def close
-      @mutex.synchronize {
+#      @mutex.synchronize {
+      @parent.single_res_mutex.synchronize {
         @query_list.each do |client_query_id, values|
           msg, client_queue, q, outstanding = values
           send_result_and_close(client_queue, client_query_id, q, nil, OtherResolvError.new("Resolver closing!"))
@@ -899,34 +821,56 @@ module Dnsruby
     # 
     # Send the result back to the client, and close the socket for that query by removing 
     # the query from the select thread.
-    def send_result_and_close(client_queue, client_query_id, select_queue, msg, error) #:nodoc: all
+    def send_result_and_stop_querying(client_queue, client_query_id, select_queue, msg, error) #:nodoc: all
+      stop_querying(client_query_id)
+      send_result(client_queue, client_query_id, select_queue, msg, error)
+    end
+
+    # MUST BE CALLED IN A SYNCHRONIZED BLOCK!
+    #
+    # Stops send any more packets for a client-level query
+    def stop_querying(client_query_id) #:nodoc: all
+      @timeouts.delete(client_query_id) 
+    end
+
+    # MUST BE CALLED IN A SYNCHRONIZED BLOCK!
+    #
+    # Sends the result to the client's queue, and removes the queue observer from the select thread
+    def send_result(client_queue, client_query_id, select_queue, msg, error) #:nodoc: all
+      stop_querying(client_query_id)  # @TODO@ !
       # We might still get some callbacks, which we should ignore
       st = SelectThread.instance
       st.remove_observer(select_queue, self)
       #      @mutex.synchronize{
       # Remove the query from all of the data structures
-      @timeouts.delete(client_query_id)
       @query_list.delete(client_query_id)
       #      }
       # Return the response to the client
-      client_queue.push([client_query_id, msg, error])
+      if (error != nil)
+        #        client_queue.push([client_query_id, Resolver::EventType::ERROR, msg, error])
+        client_queue.push([client_query_id, msg, error])
+      else
+        #        client_queue.push([client_query_id, Resolver::EventType::VALIDATED, msg, error])
+        client_queue.push([client_query_id, msg, error])
+      end
     end
     
-    # This method is called ten times a second from the select loop, in the select thread. 
-    # It should arguably be called from another worker thread... 
+    # This method is called twice a second from the select loop, in the select thread.
+    # It should arguably be called from another worker thread... (which also handles the queue)
     # Each tick, we check if any timeouts have occurred. If so, we take the appropriate action : 
     # Return a timeout to the client, or send a new query
     def tick #:nodoc: all
       # Handle the tick
       # Do we have any retries due to be sent yet?
-      @mutex.synchronize{
+#      @mutex.synchronize{
+      @parent.single_res_mutex.synchronize {
         time_now = Time.now
         @timeouts.keys.each do |client_query_id|
           msg, client_queue, select_queue, outstanding = @query_list[client_query_id]
           query_timeout, timeouts = @timeouts[client_query_id]
           if (query_timeout < Time.now)
             #Time the query out
-            send_result_and_close(client_queue, client_query_id, select_queue, nil, ResolvTimeout.new("Query timed out"))
+            send_result_and_stop_querying(client_queue, client_query_id, select_queue, nil, ResolvTimeout.new("Query timed out"))
             next
           end
           timeouts_done = []
@@ -941,11 +885,10 @@ module Dnsruby
               timeouts_done.push(timeout)
               timeouts.delete(timeout)
 
-              # Pick a new QID here
-              new_msg = msg.dup();
-              new_msg.header = msg.header.dup();
-              new_msg.header.id = rand(65535);
-              res.send_async(new_msg, select_queue, id)
+              # Pick a new QID here @TODO@ !!!
+              #              msg.header.id = rand(65535);
+              #              print "New query : #{new_msg}\n"
+              res.send_async(msg, select_queue, id)
             else
               break
             end
@@ -962,8 +905,8 @@ module Dnsruby
     # It's probably a good idea to create a new "worker thread" to take items from the select thread queue and 
     # call this method in the worker thread.
     # 
-    # Time to process a new queue event.
     def handle_queue_event(queue, id) #:nodoc: all
+      # Time to process a new queue event.
       # If we get a callback for an ID we don't know about, don't worry -
       # just ignore it. It may be for a query we've already completed.
       # 
@@ -972,98 +915,216 @@ module Dnsruby
       # @TODO@ Tick could poll the queue and then call this method if needed - no need for observer interface.
       # @TODO@ Currently, tick and handle_queue_event called from select_thread - could have thread chuck events in to tick_queue. But then, clients would have to call in on other thread!
       #
+      # So - two types of response :
+      # 1) we've got a coherent response (or error) - stop sending more packets for that query!
+      # 2) we've validated the response - it's ready to be sent to the client
+      #
+      # so need two more methods :
+      #  handleValidationResponse : basically calls send_result_and_close and
+      #  handleValidationError : does the same as handleValidationResponse, but for errors
+      # can leave handleError alone
+      # but need to change handleResponse to stop sending, rather than send_result_and_close.
+      #
+      # @TODO@ Also, we could really do with a MaxValidationTimeout - if validation not OK within
+      # this time, then raise Timeout (and stop validation)?
+      #
+      # @TODO@ Also, should there be some facility to stop validator following same chain
+      # concurrently?
+      #
+      # @TODO@ Also, should have option to speak only to configured resolvers (not follow authoritative chain)
+      #
       if (queue.empty?)
         Dnsruby.log.fatal{"Queue empty in handle_queue_event!"}
         raise RuntimeError.new("Severe internal error - Queue empty in handle_queue_event")
       end
-      event_id, response, error = queue.pop
+      event_id, event_type, response, error = queue.pop
       # We should remove this packet from the list of outstanding packets for this query
       resolver, msg, client_query_id, retry_count = id
       if (id != event_id)
         Dnsruby.log.error{"Serious internal error!! #{id} expected, #{event_id} received"}
         raise RuntimeError.new("Serious internal error!! #{id} expected, #{event_id} received")
       end
-      @mutex.synchronize{
+#      @mutex.synchronize{
+      @parent.single_res_mutex.synchronize {
         if (@query_list[client_query_id]==nil)
+          #          print "Dead query response - ignoring\n"
           Dnsruby.log.debug{"Ignoring response for dead query"}
           return
         end
         msg, client_queue, select_queue, outstanding = @query_list[client_query_id]
-        if (!outstanding.include?id)
-          Dnsruby.log.error{"Query id not on outstanding list! #{outstanding.length} items. #{id} not on #{outstanding}"}
-          raise RuntimeError.new("Query id not on outstanding!")
+        if (event_type == Resolver::EventType::RECEIVED ||
+              event_type == Resolver::EventType::ERROR)
+          if (!outstanding.include?id)
+            Dnsruby.log.error{"Query id not on outstanding list! #{outstanding.length} items. #{id} not on #{outstanding}"}
+            raise RuntimeError.new("Query id not on outstanding!")
+          end
+          outstanding.delete(id)
+        end
+        #      }
+        if (event_type == Resolver::EventType::RECEIVED)
+          #      if (event.kind_of?(Exception))
+          if (error != nil)
+            handle_error_response(queue, event_id, error, response)
+          else # if (event.kind_of?(Message))
+            handle_response(queue, event_id, response)
+            #      else
+            #        Dnsruby.log.error("Random object #{event.class} returned through queue to Resolver")
+          end
+        elsif (event_type == Resolver::EventType::VALIDATED)
+          if (error != nil)
+            handle_validation_error(queue, event_id, error, response)
+          else
+            handle_validation_response(queue, event_id, response)
+          end
+        elsif (event_type == Resolver::EventType::ERROR)
+          handle_error_response(queue, event_id, error, response)
+        else
+          #          print "ERROR - UNKNOWN EVENT TYPE IN RESOLVER : #{event_type}\n"
+          TheLog.error("ERROR - UNKNOWN EVENT TYPE IN RESOLVER : #{event_type}")
         end
-        outstanding.delete(id)
       }
-      #      if (event.kind_of?(Exception))
-      if (error != nil)
-        handle_error_response(queue, event_id, error, response)
-      else # if (event.kind_of?(Message))
-        handle_response(queue, event_id, response)
-        #      else
-        #        Dnsruby.log.error("Random object #{event.class} returned through queue to Resolver")
-      end
     end
     
     def handle_error_response(select_queue, query_id, error, response) #:nodoc: all
       #Handle an error
-      @mutex.synchronize{
-        Dnsruby.log.debug{"handling error #{error.class}, #{error}"}
-        # Check what sort of error it was :
-        resolver, msg, client_query_id, retry_count = query_id
-        msg, client_queue, select_queue, outstanding = @query_list[client_query_id]
-        if (error.kind_of?(ResolvTimeout))
-          #   - if it was a timeout, then check which number it was, and how many retries are expected on that server
-          #       - if it was the last retry, on the last server, then return a timeout to the client (and clean up)
-          #       - otherwise, continue
-          # Do we have any more packets to send to this resolver?
-          timeouts = @timeouts[client_query_id]
-          if (outstanding.empty? && timeouts[1].values.empty?)
-            Dnsruby.log.debug{"Sending timeout to client"}
-            send_result_and_close(client_queue, client_query_id, select_queue, response, error)
-          end
-        elsif (error.kind_of?NXDomain)
-          #   - if it was an NXDomain, then return that to the client, and stop all new queries (and clean up)
-          send_result_and_close(client_queue, client_query_id, select_queue, response, error)
-        else
-          #   - if it was any other error, then remove that server from the list for that query
-          #   If a Too Many Open Files error, then don't remove, but let retry work.
-          timeouts = @timeouts[client_query_id]
-          if (!(error.to_s=~/Errno::EMFILE/))
-            Dnsruby.log.debug{"Removing #{resolver.server} from resolver list for this query"}
-            timeouts[1].each do |key, value|
-              res = value[0]
-              if (res == resolver)
-                timeouts[1].delete(key)
-              end
+      #      @mutex.synchronize{
+      Dnsruby.log.debug{"handling error #{error.class}, #{error}"}
+      # Check what sort of error it was :
+      resolver, msg, client_query_id, retry_count = query_id
+      msg, client_queue, select_queue, outstanding = @query_list[client_query_id]
+      if (error.kind_of?(ResolvTimeout))
+        #   - if it was a timeout, then check which number it was, and how many retries are expected on that server
+        #       - if it was the last retry, on the last server, then return a timeout to the client (and clean up)
+        #       - otherwise, continue
+        # Do we have any more packets to send to this resolver?
+
+        decrement_resolver_priority(resolver)
+        timeouts = @timeouts[client_query_id]
+        if (outstanding.empty? && timeouts && timeouts[1].values.empty?)
+          Dnsruby.log.debug{"Sending timeout to client"}
+          send_result_and_stop_querying(client_queue, client_query_id, select_queue, response, error)
+        end
+      elsif (error.kind_of?NXDomain)
+        #   - if it was an NXDomain, then return that to the client, and stop all new queries (and clean up)
+        #        send_result_and_stop_querying(client_queue, client_query_id, select_queue, response, error)
+        increment_resolver_priority(resolver) if (!response.cached)
+        stop_querying(client_query_id)
+        # @TODO@ Does the client want notified at this point?
+      else
+        #   - if it was any other error, then remove that server from the list for that query
+        #   If a Too Many Open Files error, then don't remove, but let retry work.
+        timeouts = @timeouts[client_query_id]
+        if (!(error.to_s=~/Errno::EMFILE/))
+          Dnsruby.log.debug{"Removing #{resolver.server} from resolver list for this query"}
+          timeouts[1].each do |key, value|
+            res = value[0]
+            if (res == resolver)
+              timeouts[1].delete(key)
             end
-          else
-            Dnsruby.log.debug{"NOT Removing #{resolver.server} due to Errno::EMFILE"}
-          end
-          #        - if it was the last server, then return an error to the client (and clean up)
-          if (outstanding.empty? && timeouts[1].values.empty?)
-            #          if (outstanding.empty?)
-            Dnsruby.log.debug{"Sending error to client"}
-            send_result_and_close(client_queue, client_query_id, select_queue, response, error)
           end
+          # Also stick it to the back of the list for future queries
+          demote_resolver(resolver)
+        else
+          Dnsruby.log.debug{"NOT Removing #{resolver.server} due to Errno::EMFILE"}
         end
-        #@TODO@ If we're still sending packets for this query, but none are outstanding, then 
-        #jumpstart the next query?
-      }
+        #        - if it was the last server, then return an error to the client (and clean up)
+        if (outstanding.empty? && timeouts && timeouts[1].values.empty?)
+          #          if (outstanding.empty?)
+          Dnsruby.log.debug{"Sending error to client"}
+          send_result_and_stop_querying(client_queue, client_query_id, select_queue, response, error)
+        end
+      end
+      #@TODO@ If we're still sending packets for this query, but none are outstanding, then
+      #jumpstart the next query?
+      #      }
+    end
+
+    # TO BE CALLED IN A SYNCHRONIZED BLOCK
+    def increment_resolver_priority(res)
+      TheLog.debug("Incrementing resolver priority for #{res.server}\n")
+#      @parent.single_res_mutex.synchronize {
+        index = @parent.single_resolvers.index(res)
+        if (index > 0)
+          @parent.single_resolvers.delete(res)
+          @parent.single_resolvers.insert(index-1,res)
+        end
+#      }
+    end
+
+    # TO BE CALLED IN A SYNCHRONIZED BLOCK
+    def decrement_resolver_priority(res)
+      TheLog.debug("Decrementing resolver priority for #{res.server}\n")
+#      @parent.single_res_mutex.synchronize {
+        index = @parent.single_resolvers.index(res)
+        if (index < @parent.single_resolvers.length)
+          @parent.single_resolvers.delete(res)
+          @parent.single_resolvers.insert(index+1,res)
+        end
+#      }
+    end
+
+    # TO BE CALLED IN A SYNCHRONIZED BLOCK
+    def demote_resolver(res)
+      TheLog.debug("Demoting resolver priority for #{res.server} to bottom\n")
+#      @parent.single_res_mutex.synchronize {
+        @parent.single_resolvers.delete(res)
+        @parent.single_resolvers.push(res)
+#      }
     end
     
     def handle_response(select_queue, query_id, response) #:nodoc: all
       # Handle a good response
+      # Should also stick resolver more to the front of the list for future queries
       Dnsruby.log.debug{"Handling good response"}
       resolver, msg, client_query_id, retry_count = query_id
-      @mutex.synchronize{
-        query, client_queue, s_queue, outstanding = @query_list[client_query_id]
-        if (s_queue != select_queue)
-          Dnsruby.log.error{"Serious internal error : expected select queue #{s_queue}, got #{select_queue}"}
-          raise RuntimeError.new("Serious internal error : expected select queue #{s_queue}, got #{select_queue}")
-        end
-        send_result_and_close(client_queue, client_query_id, select_queue, response, nil)
-      }
+      increment_resolver_priority(resolver) if (!response.cached)
+      #      @mutex.synchronize{
+      query, client_queue, s_queue, outstanding = @query_list[client_query_id]
+      if (s_queue != select_queue)
+        Dnsruby.log.error{"Serious internal error : expected select queue #{s_queue}, got #{select_queue}"}
+        raise RuntimeError.new("Serious internal error : expected select queue #{s_queue}, got #{select_queue}")
+      end
+      #        send_result_and_close(client_queue, client_query_id, select_queue, response, nil)
+      stop_querying(client_query_id)
+      # @TODO@ Does the client want notified at this point?
+      #        client_queue.push([client_query_id, Resolver::EventType::RECEIVED, msg, nil])
+      #      }
+    end
+
+    def handle_validation_response(select_queue, query_id, response) #:nodoc: all
+      resolver, msg, client_query_id, retry_count = query_id
+      #      @mutex.synchronize {
+      query, client_queue, s_queue, outstanding = @query_list[client_query_id]
+      if (s_queue != select_queue)
+        Dnsruby.log.error{"Serious internal error : expected select queue #{s_queue}, got #{select_queue}"}
+        raise RuntimeError.new("Serious internal error : expected select queue #{s_queue}, got #{select_queue}")
+      end
+      if (response.rcode == RCode.NXDOMAIN)
+        send_result(client_queue, client_query_id, select_queue, response, NXDomain.new)
+      else
+        # @TODO@ Was there an error validating? Should we raise an exception for certain security levels?
+        # This should be configurable by the client.
+        #        send_result_and_close(client_queue, client_query_id, select_queue, response, nil)
+        send_result(client_queue, client_query_id, select_queue, response, nil)
+        #      }
+      end
     end
-  end   
-end
+    
+    def handle_validation_error(select_queue, query_id, error, response)
+      resolver, msg, client_query_id, retry_count = query_id
+      query, client_queue, s_queue, outstanding = @query_list[client_query_id]
+      if (s_queue != select_queue)
+        Dnsruby.log.error{"Serious internal error : expected select queue #{s_queue}, got #{select_queue}"}
+        raise RuntimeError.new("Serious internal error : expected select queue #{s_queue}, got #{select_queue}")
+      end
+      #      For some errors, we immediately send result. For others, should we retry?
+      #      Either :
+      #                handle_error_response(queue, event_id, error, response)
+      #                Or:
+      send_result(client_queue, client_query_id, select_queue, response, error)
+      #
+      #
+    end
+  end
+end
+require "Dnsruby/SingleResolver"