redns 0.1.14 → 0.1.15

data/VERSION

@@ -1 +1 @@
-0.1.14
+0.1.15

data/lib/redns/connection.rb

@@ -4,11 +4,12 @@ class ReDNS::Connection < EventMachine::Connection
   # == Constants ============================================================
   
   DEFAULT_TIMEOUT = 5
+  DEFAULT_ATTEMPTS = 2
   SEQUENCE_LIMIT = 0x10000
   
   # == Properties ===========================================================
   
-  attr_accessor :timeout
+  attr_accessor :timeout, :attempts
 
   # == Extensions ===========================================================
 
@@ -32,19 +33,20 @@ class ReDNS::Connection < EventMachine::Connection
 
   # == Instance Methods =====================================================
   
-  def post_init
-    # Sequence numbers do not have to be cryptographically secure, but having
-    # a healthy amount of randomness is a good thing.
-    @sequence = (rand(SEQUENCE_LIMIT) ^ (object_id ^ (Time.now.to_f * SEQUENCE_LIMIT).to_i)) % SEQUENCE_LIMIT
-    
-    # Callback tracking is done by matching response IDs in a lookup table
-    @callback = { }
-    
-    EventMachine.add_periodic_timer(1) do
-      check_for_timeouts!
-    end
+  # Sets the current timeout parameter to the supplied value (in seconds).
+  # If the supplied value is zero or nil, will revert to the default.
+  def timeout=(value)
+    @timeout = value.to_i
+    @timeout = DEFAULT_TIMEOUT if (@timeout == 0)
   end
-  
+
+  # Sets the current retry attempts parameter to the supplied value.
+  # If the supplied value is zero or nil, will revert to the default.
+  def attempts=(value)
+    @attempts = value.to_i
+    @attempts = DEFAULT_ATTEMPTS if (@attempts == 0)
+  end
+
   # Returns the configured list of nameservers as an Array. If not configured
   # specifically, will look in the resolver configuration file, typically
   # /etc/resolv.conf for which servers to use.
@@ -70,39 +72,33 @@ class ReDNS::Connection < EventMachine::Connection
     Socket.unpack_sockaddr_in(get_sockname)[0]
   end
   
-  def receive_data(data)
-    message = ReDNS::Message.new(ReDNS::Buffer.new(data))
-    
-    if (callback = @callback.delete(message.id))
-      answers = message.answers
-
-      # If the request was made for a specific type of record...
-      if (type = callback[:type])
-        if (type != :any)
-          # ...only include that type of answer in the result set.
-          answers = answers.select { |a| a.rtype == type }
-        end
-      end
-
-      callback[:callback].call(answers)
-    end
-  end
-  
-  def resolve(query, type = nil, &callback)
+  # Resolves a given query and optional type asynchronously, yielding to the
+  # callback function with either the answers or nil if a timeout or error
+  # occurred. The filter option will restrict responses ot those matching
+  # the requested type if true, or return all responses if false. The default
+  # is to filter responses.
+  def resolve(query, type = nil, filter = true, &callback)
     message = ReDNS::Message.question(query, type) do |m|
       m.id = @sequence
     end
+    
+    serialized_message = message.serialize.to_s
+    target_nameserver = random_nameserver
 
     result = send_datagram(
-      message.serialize.to_s,
-      random_nameserver,
+      serialized_message,
+      target_nameserver,
       ReDNS::Support.dns_port
     )
 
     if (result > 0)
       @callback[@sequence] = {
-        :callback => callback,
+        :serialized_message => serialized_message,
         :type => type,
+        :filter_by_type => (type == :any || !filter) ? false : type,
+        :nameserver => target_nameserver,
+        :attempts => self.attempts - 1,
+        :callback => callback,
         :at => Time.now
       }
     else
@@ -112,25 +108,81 @@ class ReDNS::Connection < EventMachine::Connection
     @sequence += 1
     @sequence %= SEQUENCE_LIMIT
   end
+
+  # EventMachine: Called after the connection is initialized.
+  def post_init
+    # Sequence numbers do not have to be cryptographically secure, but having
+    # a healthy amount of randomness is a good thing.
+    @sequence = (rand(SEQUENCE_LIMIT) ^ (object_id ^ (Time.now.to_f * SEQUENCE_LIMIT).to_i)) % SEQUENCE_LIMIT
+    
+    # Callback tracking is done by matching response IDs in a lookup table
+    @callback = { }
+    
+    @timeout ||= DEFAULT_TIMEOUT
+    @attempts ||= DEFAULT_ATTEMPTS
+    
+    EventMachine.add_periodic_timer(1) do
+      check_for_timeouts!
+    end
+  end
+
+  # EventMachine: Called when data is received on the active socket.
+  def receive_data(data)
+    message = ReDNS::Message.new(ReDNS::Buffer.new(data))
+    
+    if (callback = @callback.delete(message.id))
+      answers = message.answers
+
+      if (type = callback[:filter_by_type])
+        answers = answers.select { |a| a.rtype == type }
+      end
+
+      callback[:callback].call(answers)
+    end
+  end
   
+  # EventMachine: Called when the connection is closed.
   def unbind
   end
-  
+
+protected
+  # Returns the next nameserver in the list for a given entry, wrapping around
+  # to the beginning if required.
+  def nameserver_after(nameserver)
+    self.nameservers[(self.nameservers.index(nameserver).to_i + 1) % self.nameservers.length]
+  end
+
+  # Checks all pending queries for timeouts and triggers callbacks or retries
+  # if necessary.
   def check_for_timeouts!
     timeout_at = Time.now - (@timeout || DEFAULT_TIMEOUT)
-    
+  
     @callback.keys.each do |k|
-      params = @callback[k]
-
-      if (params and params[:at] < timeout_at)
-        params[:callback].call(nil)
+      if (params = @callback[k])
+        if (params[:at] < timeout_at)
+          if (params[:attempts] > 0)
+            # If this request can be retried, find a different nameserver.
+            target_nameserver = nameserver_after(params[:target_nameserver])
+            
+            # Send exactly the same request to it so that the request ID will
+            # match to the same callback.
+            send_datagram(
+              params[:serialized_message],
+              target_nameserver,
+              ReDNS::Support.dns_port
+            )
+            
+            params[:target_nameserver] = target_nameserver
+            params[:attempts] -= 1
+          else
+            params[:callback].call(nil)
+            @callback.delete(k)
+          end
+        end
+      else
+        # Was missing params so should be deleted if not already removed.
         @callback.delete(k)
       end
     end
   end
-  
-  def timeout=(value)
-    @timeout = value.to_i
-    @timeout = DEFAULT_TIMEOUT if (@timeout == 0)
-  end
 end

data/redns.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{redns}
-  s.version = "0.1.14"
+  s.version = "0.1.15"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["tadman"]
-  s.date = %q{2011-08-02}
+  s.authors = [%q{tadman}]
+  s.date = %q{2011-08-10}
   s.description = %q{ReDNS is a pure Ruby DNS library with drivers for reactor-model engines such as EventMachine}
   s.email = %q{github@tadman.ca}
   s.extra_rdoc_files = [
@@ -50,23 +50,9 @@ Gem::Specification.new do |s|
     "test/test_redns_support.rb"
   ]
   s.homepage = %q{http://github.com/tadman/redns}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.3}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.7}
   s.summary = %q{Ruby Reactor-Ready DNS Library}
-  s.test_files = [
-    "test/helper.rb",
-    "test/test_redns.rb",
-    "test/test_redns_address.rb",
-    "test/test_redns_buffer.rb",
-    "test/test_redns_connection.rb",
-    "test/test_redns_fragment.rb",
-    "test/test_redns_message.rb",
-    "test/test_redns_name.rb",
-    "test/test_redns_question.rb",
-    "test/test_redns_resolver.rb",
-    "test/test_redns_resource.rb",
-    "test/test_redns_support.rb"
-  ]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/test/test_redns_connection.rb

@@ -33,7 +33,7 @@ class TestReDNSConnection < Test::Unit::TestCase
       end
       
       # Simple reverse lookup, one PTR record
-      dns.resolve('192.0.32.10') do |result|
+      dns.resolve('192.0.43.10') do |result|
         reverse = result
 
         EventMachine.stop_event_loop if (address and reverse and nameservers and cname)
@@ -59,10 +59,9 @@ class TestReDNSConnection < Test::Unit::TestCase
     end
     
     assert_equal %w[ 192.0.43.10 ], address.collect { |a| a.rdata.to_s }
-    assert_equal %w[ www.example.com. ], reverse.collect { |a| a.rdata.to_s }
+    assert_equal %w[ 43-10.any.icann.org. ], reverse.collect { |a| a.rdata.to_s }
     assert_equal %w[ a.iana-servers.net. b.iana-servers.net. ], nameservers.collect { |a| a.rdata.to_s }.sort
     assert_equal %w[ 74.207.228.18 ], cname.collect { |a| a.rdata.to_s }
-
   end
 
   def test_simple_timeout
@@ -95,4 +94,25 @@ class TestReDNSConnection < Test::Unit::TestCase
       EventMachine.stop_event_loop
     end
   end
+  
+  def test_simple_attempts
+    address = :fail
+    
+    EventMachine.run do
+      dns = ReDNS::Connection.instance do |c|
+        c.nameservers += %w[ 127.0.0.2 127.0.0.3 127.0.0.4 127.0.0.5 127.0.0.6 127.0.0.7 127.0.0.8 127.0.0.9  ]
+        c.timeout = 1
+        c.attempts = 10
+      end
+
+      dns.resolve('example.com') do |result|
+        address = result
+        
+        EventMachine.stop_event_loop
+      end
+    end
+    
+    assert address
+    assert_equal '192.0.43.10', address.first.rdata.to_s
+  end
 end

metadata

@@ -1,28 +1,24 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: redns
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.1.15
   prerelease: 
-  version: 0.1.14
 platform: ruby
-authors: 
+authors:
 - tadman
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-02 00:00:00 -04:00
-default_executable: 
+date: 2011-08-10 00:00:00.000000000Z
 dependencies: []
-
-description: ReDNS is a pure Ruby DNS library with drivers for reactor-model engines such as EventMachine
+description: ReDNS is a pure Ruby DNS library with drivers for reactor-model engines
+  such as EventMachine
 email: github@tadman.ca
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
 - .document
 - README.rdoc
 - Rakefile
@@ -55,44 +51,28 @@ files:
 - test/test_redns_resolver.rb
 - test/test_redns_resource.rb
 - test/test_redns_support.rb
-has_rdoc: true
 homepage: http://github.com/tadman/redns
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.3
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: Ruby Reactor-Ready DNS Library
-test_files: 
-- test/helper.rb
-- test/test_redns.rb
-- test/test_redns_address.rb
-- test/test_redns_buffer.rb
-- test/test_redns_connection.rb
-- test/test_redns_fragment.rb
-- test/test_redns_message.rb
-- test/test_redns_name.rb
-- test/test_redns_question.rb
-- test/test_redns_resolver.rb
-- test/test_redns_resource.rb
-- test/test_redns_support.rb
+test_files: []