Dnsruby 0.5.0 → 0.6.0

data/lib/Dnsruby/Resolver.rb

@@ -40,10 +40,27 @@ module Dnsruby
   #=== Asynchronous
   #These methods use a response queue to return the response and the error
   #
-  #*  Dnsruby::Resolver#send_async(msg, query_id, response_queue)
+  #*  Dnsruby::Resolver#send_async(msg, response_queue, query_id)
   #
-  
+  #== 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)
   class Resolver
+    @@event_machine_available=false
+    begin
+      require 'Dnsruby/event_machine_interface'
+      @@event_machine_available=true
+      TheLog.debug("EventMachine loaded")
+    rescue LoadError
+      TheLog.error("EventMachine not found")
+    end
     DefaultQueryTimeout = 0 
     DefaultPacketTimeout = 10
     DefaultRetryTimes = 4
@@ -100,6 +117,9 @@ module Dnsruby
     # being targetted, and a new nameserver will be queried with the resultant delay.
     attr_accessor :retry_times, :retry_delay
     
+    @@use_eventmachine=false
+    @@start_eventmachine_loop=true
+    
     #--
     #@TODO@ add load_balance? i.e. Target nameservers in a random, rather than pre-determined, order?
     #++
@@ -147,16 +167,6 @@ module Dnsruby
       else
         return result
       end
-      #      case result
-      #      when Exception
-      #        # Pass them on
-      #        raise result
-      #      when Message
-      #        return result
-      #      else
-      #        TheLog.error("Unknown result returned : #{result}")
-      #        raise ResolvError.new("Unknown error, return : #{result}")
-      #      end 
     end
     
     
@@ -173,9 +183,9 @@ module Dnsruby
     #   res = Dnsruby::Resolver.new
     #   query_id = 10 # can be any object you like
     #   query_queue = Queue.new
-    #   res.send_async(Message.new("example.com", Types.MX), query_id,  query_queue)
+    #   res.send_async(Message.new("example.com", Types.MX),  query_queue, query_id)
     #   query_id += 1
-    #   res.send_async(Message.new("example.com", Types.A), query_id,  query_queue)
+    #   res.send_async(Message.new("example.com", Types.A), query_queue, query_id)
     #   # ...do a load of other stuff here...
     #   2.times do 
     #     response_id, response, exception = query_queue.pop
@@ -186,7 +196,463 @@ module Dnsruby
     #         # deal with problem
     #     end
     #   end
-    def send_async(msg, client_query_id, client_queue)
+    # @TODO@ Sort out RDoc arguments to send_async!
+    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)
+      end
+    end
+    
+    # Close the Resolver. Unfinished queries are terminated with OtherResolvError.
+    def close
+      [@resolver_em, @resolver_ruby].each do |r| r.close if r end
+    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 : 
+    # 
+    # 
+    # * :port
+    # * :use_tcp
+    # * :tsig_key
+    # * :ignore_truncation
+    # * :src_address
+    # * :src_port
+    # * :persistent_tcp
+    # * :persistent_udp
+    # * :recurse
+    # * :udp_size
+    # * :config_info - see Config
+    # * :nameserver - can be either a String or an array of Strings
+    # * :packet_timeout
+    # * :query_timeout
+    # * :retry_times
+    # * :retry_delay
+    def initialize(*args)
+      reset_attributes
+      
+      # Process args
+      if (args.length==1)
+        if (args[0].class == Hash)
+          args[0].keys.each do |key|
+            begin
+              if (key == :config_info)
+                @config.set_config_info(args[0][:config_info])
+              elsif (key==:nameserver)
+                set_config_nameserver(args[0][:nameserver])
+              else
+                send(key.to_s+"=", args[0][key])
+              end
+            rescue Exception
+              TheLog.error("Argument #{key} not valid\n")
+            end
+          end
+        elsif (args[0].class == String)
+          set_config_nameserver(args[0])          
+        elsif (args[0].class == Config)
+          # also accepts a Config object from Dnsruby::Resolv
+          @config = args[0]
+        end
+      else
+        #@TODO@ ?
+      end
+      if (@single_resolvers==[])
+        add_config_nameservers
+      end
+      update
+    end
+    
+    def add_config_nameservers
+      # Add the Config nameservers
+      @config.nameserver.each do |ns|
+        @single_resolvers.push(SingleResolver.new({:server=>ns}))
+      end
+    end
+    
+    def set_config_nameserver(n)
+      if (n).kind_of?String
+        @config.nameserver=[n]
+      else
+        @config.nameserver=n
+      end
+    end    
+    
+    def reset_attributes #:nodoc: all
+      if (@resolver_em)
+        @resolver_em.reset_attributes
+      end
+      if (@resolver_ruby)
+        @resolver_ruby.reset_attributes
+      end
+     
+      # Attributes
+      @query_timeout = DefaultQueryTimeout
+      @retry_delay = DefaultRetryDelay
+      @retry_times = DefaultRetryTimes
+      @packet_timeout = DefaultPacketTimeout
+      @port = DefaultPort
+      @udp_size = DefaultUDPSize
+      @use_tcp = false
+      @tsig_key = nil
+      @ignore_truncation = false
+      @config = Config.new()
+      @src_addr        = '0.0.0.0'
+      @src_port        = 0
+      @recurse = true
+      @persistent_udp = false
+      @persistent_tcp = false
+      @single_resolvers=[]
+    end
+    
+    def update #:nodoc: all
+      #Update any resolvers we have with the latest config
+      @single_resolvers.each do |res|
+        [:port, :use_tcp, :tsig_key, :ignore_truncation, :packet_timeout, 
+          :src_address, :src_port, :persistent_tcp, :persistent_udp, :recurse, 
+          :udp_size].each do |param|
+          
+          res.send(param.to_s+"=", instance_variable_get("@"+param.to_s))
+        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)
+    end
+    
+    def nameserver=(n)
+      @single_resolvers=[]
+      set_config_nameserver(n)
+      add_config_nameservers
+    end
+    
+    def packet_timeout=(t)
+      @packet_timeout = t
+      update
+    end
+    
+    def port=(p)
+      @port = p
+      update
+    end
+    
+    def use_tcp=(on)
+      @use_tcp = on
+      update
+    end
+    
+    def tsig_key=(t)
+      @tsig_key = t
+      update
+    end
+    
+    def ignore_truncation=(on)
+      @ignore_truncation = on
+      update
+    end
+    
+    def src_address=(a)
+      @src_address = a
+      update
+    end
+    
+    def src_port=(a)
+      @src_port = a
+      update
+    end
+    
+    def persistent_tcp=(on)
+      @persistent_tcp = on
+      update
+    end
+    
+    def persistent_udp=(on)
+      @persistent_udp = on
+      update
+    end
+    
+    def recurse=(a)
+      @recurse = a
+      update
+    end
+    
+    def udp_size=(s)
+      @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 (!@@event_machine_available)
+        raise RuntimeError.new("EventMachine is not available in this environment!")
+      end
+      @@use_eventmachine = on
+      if (on)
+        TheLog.info("EventMachine will be used for IO")
+      else
+        TheLog.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)
+        TheLog.info("EventMachine loop will be started by Dnsruby")
+      else
+        TheLog.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
+    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))
+              TheLog.error("Duplicate timeout key!")
+              raise RuntimeError.new("Duplicate timeout key!")
+            end
+            timeouts[base+retry_delay+offset]=[res, retry_count]
+          end
+        end
+      end
+      return timeouts      
+    end
+  end
+  
+  # This class implements the I/O using EventMachine.
+  # 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
+          TheLog.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{
+            TheLog.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
+    
+    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)
+      df = single_resolver.send_async(msg) # client_queue, client_query_id)
+      persistent_data.to_send-=1
+      df.callback { |answer|
+        TheLog.debug("Response returned, answer=#{answer}")
+        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|
+        TheLog.debug("Error #{error} returned, response=#{response}")
+        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)
+              TheLog.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)
+            TheLog.debug("NXDomain - 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)
+              TheLog.debug("Removing #{single_resolver.server} from resolver list for this query")
+            else
+              TheLog.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?)
+              TheLog.debug("Sending error to client")
+              return_to_client(persistent_data.deferrable, client_queue, client_query_id, response, error)
+            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)
+      TheLog.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)
+      TheLog.debug("Returning answer=#{answer}, error=#{error} to client")
+      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)
+    end
+  end
+
+  # This class implements the I/O using pure Ruby, with no dependencies.
+  class ResolverRuby #:nodoc: all
+    def initialize(parent)
+      reset_attributes
+      @parent=parent
+    end
+    def reset_attributes #:nodoc: all
+      # data structures
+      @mutex=Mutex.new
+      @query_list = {}
+      @timeouts = {}
+    end
+    def send_async(*args) # msg, client_queue, client_query_id=nil)
+      msg=args[0]
+      client_queue=nil
+      client_query_id=nil
+        client_queue=args[1]
+        if (args.length > 2)
+          client_query_id = args[2]
+      end
+      
       # This is the whole point of the Resolver class.
       # We want to use multiple SingleResolvers to run a query.
       # So we kick off a system with select_thread where we send
@@ -197,6 +663,9 @@ module Dnsruby
       # to the client queue.
       
       q = Queue.new
+      if (client_query_id==nil)
+        client_query_id = msg
+      end
       
       if (!client_queue.kind_of?Queue)
         TheLog.error("Wrong type for client_queue in Resolver#send_async")
@@ -222,8 +691,8 @@ module Dnsruby
         outstanding = []
         @query_list[client_query_id]=[msg, client_queue, q, outstanding]
         
-        query_timeout = Time.now+@query_timeout
-        if (@query_timeout == 0)
+        query_timeout = Time.now+@parent.query_timeout
+        if (@parent.query_timeout == 0)
           query_timeout = Time.now+31536000 # a year from now
         end
         @timeouts[client_query_id]=[query_timeout, generate_timeouts()]
@@ -234,6 +703,7 @@ module Dnsruby
       st = SelectThread.instance
       st.add_observer(q, self)
       tick if tick_needed
+      return client_query_id
     end
     
     def generate_timeouts() #:nodoc: all
@@ -243,34 +713,11 @@ module Dnsruby
       # These should be absolute, rather than relative
       # The first value should be Time.now
       time_now = Time.now
-      timeouts={}
-      #These should be be pegged to the single_resolver they are targetting :
-      #  e.g. timeouts[timeout1]=nameserver
-      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[time_now+offset]=[res, retry_count]
-          else
-            if (timeouts.has_key?(time_now+retry_delay+offset))
-              TheLog.error("Duplicate timeout key!")
-              raise RuntimeError.new("Duplicate timeout key!")
-            end
-            timeouts[time_now+retry_delay+offset]=[res, retry_count]
-          end
-        end
-      end
-      return timeouts      
+      timeouts=@parent.generate_timeouts(time_now)
+      return timeouts
     end
     
-    # Close the Resolver. Unfinished queries are terminated with OtherResolError.
+    # Close the Resolver. Unfinished queries are terminated with OtherResolvError.
     def close
       @mutex.synchronize {
         @query_list.each do |client_query_id, values|
@@ -326,7 +773,7 @@ module Dnsruby
               outstanding.push(id)
               timeouts_done.push(timeout)
               timeouts.delete(timeout)
-              res.send_async(msg, id, select_queue)
+              res.send_async(msg, select_queue, id)
             else
               break
             end
@@ -349,6 +796,10 @@ module Dnsruby
       # just ignore it. It may be for a query we've already completed.
       # 
       # So, get the next response from the queue (presuming there is one!)
+      #
+      # @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!
+      #
       if (queue.empty?)
         TheLog.fatal("Queue empty in handle_queue_event!")
         raise RuntimeError.new("Severe internal error - Queue empty in handle_queue_event")
@@ -442,177 +893,5 @@ module Dnsruby
         send_result_and_close(client_queue, client_query_id, select_queue, response, nil)
       }
     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 : 
-    # 
-    # 
-    # * :port
-    # * :use_tcp
-    # * :tsig_key
-    # * :ignore_truncation
-    # * :src_address
-    # * :src_port
-    # * :persistent_tcp
-    # * :persistent_udp
-    # * :recurse
-    # * :udp_size
-    # * :config_info - see Config
-    # * :nameserver - can be either a String or an array of Strings
-    # * :packet_timeout
-    # * :query_timeout
-    # * :retry_times
-    # * :retry_delay
-    def initialize(*args)
-      reset_attributes
-      
-      # Process args
-      if (args.length==1)
-        if (args[0].class == Hash)
-          args[0].keys.each do |key|
-            begin
-              if (key == :config_info)
-                @config.set_config_info(args[0][:config_info])
-              elsif (key==:nameserver)
-                set_config_nameserver(args[0][:nameserver])
-              else
-                send(key.to_s+"=", args[0][key])
-              end
-            rescue Exception
-              TheLog.error("Argument #{key} not valid\n")
-            end
-          end
-        elsif (args[0].class == Config)
-          # also accepts a Config object from Dnsruby::Resolv
-          @config = args[0]
-        end
-      else
-        #@TODO@ ?
-      end
-      if (@single_resolvers==[])
-        add_config_nameservers
-      end
-      update
-    end
-    
-    def add_config_nameservers
-      # Add the Config nameservers
-      @config.nameserver.each do |ns|
-        @single_resolvers.push(SingleResolver.new({:server=>ns}))
-      end
-    end
-    
-    def set_config_nameserver(n)
-      if (n).kind_of?String
-        @config.nameserver=[n]
-      else
-        @config.nameserver=n
-      end
-    end    
-    
-    def reset_attributes #:nodoc: all
-      # data structures
-      @mutex=Mutex.new
-      @query_list = {}
-      
-      # Attributes
-      @timeouts = {}
-      @query_timeout = DefaultQueryTimeout
-      @retry_delay = DefaultRetryDelay
-      @retry_times = DefaultRetryTimes
-      @packet_timeout = DefaultPacketTimeout
-      @port = DefaultPort
-      @udp_size = DefaultUDPSize
-      @use_tcp = false
-      @tsig_key = nil
-      @ignore_truncation = false
-      @config = Config.new()
-      @src_addr        = '0.0.0.0'
-      @src_port        = 0
-      @recurse = true
-      @persistent_udp = false
-      @persistent_tcp = false
-      @single_resolvers=[]
-    end
-    
-    def update #:nodoc: all
-      #Update any resolvers we have with the latest config
-      @single_resolvers.each do |res|
-        [:port, :use_tcp, :tsig_key, :ignore_truncation, :packet_timeout, 
-          :src_address, :src_port, :persistent_tcp, :persistent_udp, :recurse, 
-          :udp_size].each do |param|
-          
-          res.send(param.to_s+"=", instance_variable_get("@"+param.to_s))
-        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)
-    end
-    
-    def nameserver=(n)
-      @single_resolvers=[]
-      set_config_nameserver(n)
-      add_config_nameservers
-    end
-    
-    def packet_timeout=(t)
-      @packet_timeout = t
-      update
-    end
-    
-    def port=(p)
-      @port = p
-      update
-    end
-    
-    def use_tcp=(on)
-      @use_tcp = on
-      update
-    end
-    
-    def tsig_key=(t)
-      @tsig_key = t
-      update
-    end
-    
-    def ignore_truncation=(on)
-      @ignore_truncation = on
-      update
-    end
-    
-    def src_address=(a)
-      @src_address = a
-      update
-    end
-    
-    def src_port=(a)
-      @src_port = a
-      update
-    end
-    
-    def persistent_tcp=(on)
-      @persistent_tcp = on
-      update
-    end
-    
-    def persistent_udp=(on)
-      @persistent_udp = on
-      update
-    end
-    
-    def recurse=(a)
-      @recurse = a
-      update
-    end
-    
-    def udp_size=(s)
-      @udp_size = s
-      update
-    end
-  end
+  end   
 end