elbping 0.0.9 → 0.0.10

data/lib/elbping/resolver.rb

@@ -1,43 +1,72 @@
 
-require 'net/dns'
-require 'ipaddress'
+require 'resolv'
+
+class TcpDNS < Resolv::DNS
+  # This is largely a copy-paste job from mri/source/lib/resolv.rb
+  def fetch_resource(name, typeclass)
+    lazy_initialize
+    request = make_tcp_requester
+    sends = {}
+    begin
+      @config.resolv(name) { |candidate, tout, nameserver, port|
+        msg = Message.new
+        msg.rd = 1
+        msg.add_question(candidate, typeclass)
+        unless sender = senders[[candidate, nameserver, port]]
+          sender = senders[[candidate, nameserver, port]] =
+            requester.sender(msg, candidate, nameserver, port)
+        end
+        reply, reply_name = requester.request(sender, tout)
+        case reply.rcode
+        when RCode::NoError
+          if reply.tc == 1 and not Requester::TCP === requester
+            requester.close
+            # Retry via TCP:
+            requester = make_tcp_requester(nameserver, port)
+            senders = {}
+            # This will use TCP for all remaining candidates (assuming the
+            # current candidate does not already respond successfully via
+            # TCP).  This makes sense because we already know the full
+            # response will not fit in an untruncated UDP packet.
+            redo
+          else
+            yield(reply, reply_name)
+          end
+          return
+        when RCode::NXDomain
+          raise Config::NXDomain.new(reply_name.to_s)
+        else
+          raise Config::OtherResolvError.new(reply_name.to_s)
+        end
+      }
+    ensure
+      requester.close
+    end
+  end
+end
 
 module ElbPing
   module Resolver
     def self.resolve_ns(nameserver)
-      # Resolve nameserver IP (you can't just plug a hostname into Net::DNS::Resolve)
-      # Return an empty list if can't look up nameserver address
-      if IPAddress.valid? nameserver
-        ns_addrs = [nameserver]
-      else
-        begin
-          ns_addrs = Resolver(nameserver).answer.map { |rr| rr.address.to_s }
-        rescue
-          ns_addrs = []
-        end
-      end
+      # Leftover from a resolver lib that wouldn't resolve its own nameservers
+      return [nameserver]
     end
 
     # Resolve an ELB address to a list of node IPs. Should always return a list
     # as long as the server responded, even if it's empty.
-    def self.find_elb_nodes(target, nameserver)
+    def self.find_elb_nodes(target, nameserver, timeout=5)
+      # `timeout` is in seconds
       ns_addrs = resolve_ns nameserver
 
       # Now resolve our ELB nodes
-      resolver = Net::DNS::Resolver.new(
-        :use_tcp => true,
-        :nameservers => ns_addrs,
-        :retry => 5)
-      begin
-        resp = resolver.query(target, Net::DNS::ANY)
-      rescue ArgumentError
-        # For some reason this is raised on timeout
-        raise "Error querying DNS: Probably a timeout"
+      resp = nil
+      Timeout::timeout(timeout) do 
+        TcpDNS.open :nameserver => ns_addrs, :search => '', :ndots => 1 do |dns|
+          # TODO: Exceptions
+          resp = dns.getresources target, Resolv::DNS::Resource::IN::A
+        end
       end
-
-      nodes = []
-      resp.each_address { |a| nodes += [a.to_s] }
-      nodes
+      resp.map { |r| r.address.to_s }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elbping
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -95,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Small tool to 'ping' the nodes that make up an Amazon Elastic Load Balancer