net-dns 0.5.3 → 0.6.0

data/lib/net/dns/resolver/timeouts.rb

@@ -1,73 +1,79 @@
 require 'timeout'
 
-module SecondsHandle #:nodoc: all
-  def transform(secs)
-    case secs
-    when 0
-      to_s
-    when 1..59
-      "#{secs} seconds"
-    when 60..3559
-      "#{secs/60} minutes and #{secs%60} seconds"
-    else
-      hours = secs/3600
-      secs -= (hours*3600)
-      "#{hours} hours, #{secs/60} minutes and #{secs%60} seconds"
-    end
-  end
-end
+module Net # :nodoc:
+  module DNS
+    class Resolver
 
-class DnsTimeout # :nodoc: all
+      class DnsTimeout
+
+        attr_reader :seconds
+
+
+        def initialize(seconds)
+          if seconds.is_a? Numeric and seconds >= 0
+            @seconds = seconds
+          else
+            raise ::ArgumentError, "Invalid value for tcp timeout"
+          end
+        end
+
+        # Returns a string representation of the timeout corresponding
+        # to the number of <tt>@seconds</tt>.
+        def to_s
+          if @seconds == 0
+            @output.to_s
+          else
+            @seconds.to_s
+          end
+        end
+
+        def pretty_to_s
+          transform(@seconds)
+        end
+
+        # Executes the method's block. If the block execution terminates before +sec+
+        # seconds has passed, it returns true. If not, it terminates the execution
+        # and raises Timeout::Error.
+        # If @seconds is 0 or nil, no timeout is set.
+        def timeout(&block)
+          raise LocalJumpError, "no block given" unless block_given?
+          Timeout.timeout(@seconds, &block)
+        end
+
+
+        private
+
+          def transform(secs)
+            case secs
+              when 0
+                to_s
+              when 1..59
+                "#{secs} seconds"
+              when 60..3559
+                "#{secs / 60} minutes and #{secs % 60} seconds"
+              else
+                hours = secs / 3600
+                secs -= (hours * 3600)
+                "#{hours} hours, #{secs / 60} minutes and #{secs % 60} seconds"
+            end
+          end
 
-  include SecondsHandle
-  
-  def initialize(seconds)
-    if seconds.is_a? Numeric and seconds >= 0
-      @timeout = seconds
-    else
-      raise DnsTimeoutArgumentError, "Invalid value for tcp timeout"
-    end    
-  end
-  
-  def to_s
-    if @timeout == 0 
-      @output
-    else
-      @timeout.to_s
-    end
-  end
-  
-  def pretty_to_s
-    transform(@timeout)
-  end
-  
-  def timeout
-    unless block_given?
-      raise DnsTimeoutArgumentError, "Block required but missing"
-    end
-    if @timeout == 0
-      yield
-    else
-      return Timeout.timeout(@timeout) do
-        yield
       end
-    end
-  end
-end
 
-class TcpTimeout < DnsTimeout # :nodoc: all
-  def initialize(seconds)
-    @output = "infinite"
-    super(seconds)
-  end
-end
+      class TcpTimeout < DnsTimeout
+        def initialize(seconds)
+          @output = "infinite"
+          super
+        end
+      end
 
-class UdpTimeout < DnsTimeout # :nodoc: all
-  def initialize(seconds)
-    @output = "not defined"
-    super(seconds)
-  end
-end
+      class UdpTimeout < DnsTimeout
+        def initialize(seconds)
+          @output = "not defined"
+          super
+        end
+      end
 
-class DnsTimeoutArgumentError < ArgumentError # :nodoc: all
-end
+    end
+  end
+end

data/lib/net/dns/rr.rb

@@ -1,7 +1,3 @@
-#
-#       $Id: RR.rb,v 1.19 2006/07/28 07:33:36 bluemonk Exp $    
-#
-
 require 'net/dns/names/names'
 require 'net/dns/rr/types'
 require 'net/dns/rr/classes'
@@ -14,16 +10,9 @@ end
 module Net # :nodoc:
   module DNS 
     
-    # =Name
-    #
-    # Net::DNS::RR - DNS Resource Record class
     #
-    # =Synopsis
-    # 
-    #   require 'net/dns/rr'
+    # = Net::DNS::RR - DNS Resource Record class
     #
-    # =Description
-    # 
     # The Net::DNS::RR is the base class for DNS Resource 
     # Record (RR) objects. A RR is a pack of data that represents
     # resources for a DNS zone. The form in which this data is 
@@ -50,30 +39,36 @@ module Net # :nodoc:
     # such the ones above, or specifying each field as the pair
     # of an hash. See the Net::DNS::RR.new method for details.
     #
-    # =Error classes
+    # == Error classes
     #
     # Some error classes has been defined for the Net::DNS::RR class,
     # which are listed here to keep a light and browsable main documentation.
     # We have:
     #
-    # * RRArgumentError: Generic argument error for class Net::DNS::RR
-    # * RRDataError: Error in parsing binary data, maybe from a malformed packet
-    #
-    # =Copyright
-    # 
-    # Copyright (c) 2006 Marco Ceresa
-    #
-    # All rights reserved. This program is free software; you may redistribute 
-    # it and/or modify it under the same terms as Ruby itself.
+    # ArgumentError:: Generic argument error for class Net::DNS::RR
+    # DataError::     Error in parsing binary data, maybe from a malformed packet.
     #
     class RR
       include Net::DNS::Names
       
+      # Argument Error for class Net::DNS::RR.
+      class ArgumentError < ArgumentError
+      end
+      
+      # Base error class.
+      class Error < StandardError
+      end
+      
+      # Error in parsing binary data, maybe from a malformed packet.
+      class DataError < Error
+      end
+      
+      
       # Regexp matching an RR string
       RR_REGEXP = Regexp.new("^\\s*(\\S+)\\s*(\\d+)?\\s+(" +
                                Net::DNS::RR::Classes.regexp + 
                                "|CLASS\\d+)?\\s*(" +
-                               Net::DNS::RR::Types.regexp + 
+                               Net::DNS::RR::Types.regexp +
                                "|TYPE\\d+)?\\s*(.*)$", Regexp::IGNORECASE)
 
       # Dimension of the sum of class, type, TTL and rdlength fields in a
@@ -131,13 +126,13 @@ module Net # :nodoc:
       # for the resource in each subclass.
       # 
       def initialize(arg)
-        case arg
-        when String
-          instance = new_from_string(arg)
-        when Hash
-          instance = new_from_hash(arg)
-        else
-          raise RRArgumentError, "Invalid argument, must be a RR string or an hash of values"
+        instance = case arg
+          when String
+            new_from_string(arg)
+          when Hash
+            new_from_hash(arg)
+          else
+            raise ArgumentError, "Invalid argument, must be a RR string or an hash of values"
         end
 
         if @type.to_s == "ANY"
@@ -205,17 +200,16 @@ module Net # :nodoc:
         return str + [type,cls,@ttl,@rdlength].pack("n2 N n") + get_data
       end
       
-      # Canonical inspect method    
+      # Canonical inspect method.
       #
       #   mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
-      #     #=> example.com.            7200    IN      MX      10 mailhost.example.com.
+      #   #=> example.com.            7200    IN      MX      10 mailhost.example.com.
       #
       def inspect
         data = get_inspect 
         # Returns the preformatted string
         if @name.size < 24
-          [@name, @ttl.to_s, @cls.to_s, @type.to_s, 
-            data].pack("A24 A8 A8 A8 A*")
+          [@name, @ttl.to_s, @cls.to_s, @type.to_s, data].pack("A24 A8 A8 A8 A*")
         else
           to_a.join("   ")
         end
@@ -225,20 +219,20 @@ module Net # :nodoc:
       #
       #   mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
       #   mx.to_s
-      #     #=> "example.com.            7200    IN      MX      10 mailhost.example.com."
+      #   #=> "example.com.            7200    IN      MX      10 mailhost.example.com."
       #
       def to_s
-        "#{self.inspect}"
+        inspect.to_s
       end
 
       # Returns an array with all the fields for the RR record.
       #
       #   mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
       #   mx.to_a
-      #     #=> ["example.com.",7200,"IN","MX","10 mailhost.example.com."]
+      #   #=> ["example.com.",7200,"IN","MX","10 mailhost.example.com."]
       #
       def to_a
-        [@name,@ttl,@cls.to_s,@type.to_s,get_inspect]
+        [@name, @ttl, @cls.to_s, @type.to_s, get_inspect]
       end
       
       # Type accessor
@@ -252,111 +246,113 @@ module Net # :nodoc:
       end
       
       private
-      
-      #---
-      # New RR with argument in string form
-      #---
-      def new_from_string(rrstring)
 
-        unless rrstring =~ RR_REGEXP
-          raise RRArgumentError, 
-          "Format error for RR string (maybe CLASS and TYPE not valid?)"
-        end
+        #---
+        # New RR with argument in string form
+        #---
+        def new_from_string(rrstring)
 
-        # Name of RR - mandatory
-        begin
-          @name = $1.downcase
-        rescue NoMethodError
-          raise RRArgumentError, "Missing name field in RR string #{rrstring}"
-        end
-        
-        # Time to live for RR, default 3 hours
-        @ttl = $2 ? $2.to_i : 10800
-        
-        # RR class, default to IN
-        @cls = Net::DNS::RR::Classes.new $3
-        
-        # RR type, default to A
-        @type = Net::DNS::RR::Types.new $4
-        
-        # All the rest is data 
-        @rdata = $5 ? $5.strip : ""  
-        
-        if self.class == Net::DNS::RR
-          (eval "Net::DNS::RR::#@type").new(rrstring)
-        else
-          subclass_new_from_string(@rdata)
-          self.class
-        end
-      end
-      
-      def new_from_hash(args)
-        
-        # Name field is mandatory   
-        unless args.has_key? :name 
-          raise RRArgumentError, "RR argument error: need at least RR name"
+          unless rrstring =~ RR_REGEXP
+            raise ArgumentError,
+            "Format error for RR string (maybe CLASS and TYPE not valid?)"
+          end
+
+          # Name of RR - mandatory
+          begin
+            @name = $1.downcase
+          rescue NoMethodError
+            raise ArgumentError, "Missing name field in RR string #{rrstring}"
+          end
+
+          # Time to live for RR, default 3 hours
+          @ttl = $2 ? $2.to_i : 10800
+
+          # RR class, default to IN
+          @cls = Net::DNS::RR::Classes.new $3
+
+          # RR type, default to A
+          @type = Net::DNS::RR::Types.new $4
+
+          # All the rest is data
+          @rdata = $5 ? $5.strip : ""
+
+          if self.class == Net::DNS::RR
+            (eval "Net::DNS::RR::#@type").new(rrstring)
+          else
+            subclass_new_from_string(@rdata)
+            self.class
+          end
         end
 
-        @name  = args[:name].downcase
-        @ttl   = args[:ttl] ? args[:ttl].to_i : 10800 # Default 3 hours
-        @type  = Net::DNS::RR::Types.new args[:type]
-        @cls  = Net::DNS::RR::Classes.new args[:cls]
-        
-        @rdata = args[:rdata] ? args[:rdata].strip : ""
-        @rdlength = args[:rdlength] || @rdata.size
+        def new_from_hash(args)
+          # Name field is mandatory
+          unless args.has_key? :name
+            raise ArgumentError, "RR argument error: need at least RR name"
+          end
 
-        if self.class == Net::DNS::RR
-          (eval "Net::DNS::RR::#@type").new(args)
-        else
-          hash = args - [:name,:ttl,:type,:cls]
-          if hash.has_key? :rdata
-            subclass_new_from_string(hash[:rdata])
+          @name  = args[:name].downcase
+          @ttl   = args[:ttl] ? args[:ttl].to_i : 10800 # Default 3 hours
+          @type  = Net::DNS::RR::Types.new args[:type]
+          @cls  = Net::DNS::RR::Classes.new args[:cls]
+
+          @rdata = args[:rdata] ? args[:rdata].strip : ""
+          @rdlength = args[:rdlength] || @rdata.size
+
+          if self.class == Net::DNS::RR
+            (eval "Net::DNS::RR::#@type").new(args)
+          else
+            hash = args - [:name,:ttl,:type,:cls]
+            if hash.has_key? :rdata
+              subclass_new_from_string(hash[:rdata])
+            else
+              subclass_new_from_hash(hash)
+            end
+            self.class
+          end
+        end # new_from_hash
+
+        def new_from_binary(data,offset)
+          if self.class == Net::DNS::RR
+            temp = dn_expand(data,offset)[1]
+            type = Net::DNS::RR::Types.new data.unpack("@#{temp} n")[0]
+            (eval "Net::DNS::RR::#{type}").parse_packet(data,offset)
           else
-            subclass_new_from_hash(hash)
+            @name,offset = dn_expand(data,offset)
+            rrtype,cls,@ttl,@rdlength = data.unpack("@#{offset} n2 N n")
+            @type = Net::DNS::RR::Types.new rrtype
+            @cls = Net::DNS::RR::Classes.new cls
+            offset += RRFIXEDSZ
+            offset = subclass_new_from_binary(data,offset)
+            build_pack
+            set_type
+            return [self,offset]
           end
-          self.class
         end
-      end # new_from_hash
 
-      def new_from_binary(data,offset)
-        if self.class == Net::DNS::RR
-          temp = dn_expand(data,offset)[1]
-          type = Net::DNS::RR::Types.new data.unpack("@#{temp} n")[0]
-          (eval "Net::DNS::RR::#{type}").parse_packet(data,offset)
-        else
-          @name,offset = dn_expand(data,offset)
-          rrtype,cls,@ttl,@rdlength = data.unpack("@#{offset} n2 N n")
-          @type = Net::DNS::RR::Types.new rrtype
-          @cls = Net::DNS::RR::Classes.new cls
-          offset += RRFIXEDSZ
-          offset = subclass_new_from_binary(data,offset)
-          build_pack
-          set_type
-          return [self,offset]
+        # Methods to be overridden by subclasses
+        def subclass_new_from_array(arr)
+        end
+        def subclass_new_from_string(str)
+        end
+        def subclass_new_from_hash(hash)
+        end
+        def subclass_new_from_binary(data,offset)
+        end
+        def build_pack
+        end
+        def get_inspect
+          @rdata
+        end
+        def get_data
+          @rdata
         end
-#      rescue StandardError => err
-#        raise RRDataError, "Caught exception, maybe packet malformed: #{err}"
-      end
-      
-      # Methods to be overridden by subclasses
-      def subclass_new_from_array(arr)
-      end
-      def subclass_new_from_string(str)
-      end
-      def subclass_new_from_hash(hash)
-      end
-      def subclass_new_from_binary(data,offset)
-      end
-      def build_pack
-      end
-      def set_type
-      end
-      def get_inspect
-        @rdata
-      end
-      def get_data
-        @rdata
-      end
+
+        def set_type
+          # TODO: Here we should probably
+          # raise NotImplementedError
+          # if we want the method to be implemented in any subclass.
+        end
+
 
       # NEW new method :)
       def self.new(*args)
@@ -369,38 +365,7 @@ module Net # :nodoc:
         end
       end
             
-    end # class RR
-    
-  end # module DNS
-end # module Net
-
-class RRArgumentError < ArgumentError # :nodoc:
-end
-class RRDataError < StandardError # :nodoc:
-end
-
-module ExtendHash # :nodoc:
-  
-  # Performs a sort of group difference 
-  # operation on hashes or arrays
-  # 
-  #   a = {:a=>1,:b=>2,:c=>3}
-  #   b = {:a=>1,:b=>2}
-  #   c = [:a,:c]
-  #   a-b #=> {:c=>3}
-  #   a-c #=> {:b=>2}
-  #
-  def -(oth)
-    case oth
-    when Hash
-      delete_if {|k,v| oth.has_key? k}
-    when Array
-      delete_if {|k,v| oth.include? k}
     end
+    
   end
-end
-
-class Hash # :nodoc:
-  include ExtendHash
-end
-
+end