net-ping 1.1.1 → 1.2.0

data/lib/net/ping/udp.rb

@@ -0,0 +1,90 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+
+module Net
+   class Ping::UDP < Ping
+      MAX_DATA = 64
+      
+      # The data to send to the remote host.  By default this is 'ping'.
+      # This should be MAX_DATA size characters or less.
+      # 
+      attr_reader :data
+      
+      # Creates and returns a new Ping::UDP object.  This is effectively
+      # identical to its superclass constructor.
+      # 
+      def initialize(host=nil, port=nil, timeout=5)
+         @data = 'ping'
+
+         super(host, port, timeout)
+
+         @bind_host = nil
+         @bind_port = nil
+      end
+      
+      # Sets the data string sent to the remote host.  This value cannot have
+      # a size greater than MAX_DATA.
+      # 
+      def data=(string)
+         if string.size > MAX_DATA
+            err = "cannot set data string larger than #{MAX_DATA} characters"
+            raise ArgumentError, err
+         end
+         
+         @data = string
+      end
+
+      # Associates the local end of the UDP connection with the given +host+
+      # and +port+.  This is essentially a wrapper for UDPSocket#bind.
+      #
+      def bind(host, port)
+         @bind_host = host
+         @bind_port = port
+      end
+
+      # Sends a simple text string to the host and checks the return string.  If
+      # the string sent and the string returned are a match then the ping was
+      # successful and true is returned.  Otherwise, false is returned.
+      #
+      def ping(host = @host)
+         super(host)
+
+         bool = false
+         udp     = UDPSocket.open
+         array   = []
+
+         if @bind_host
+            udp.bind(@bind_host, @bind_port)
+         end
+
+         start_time = Time.now
+
+         begin
+            Timeout.timeout(@timeout){
+               udp.connect(host, @port)
+               udp.send(@data, 0)
+               array = udp.recvfrom(MAX_DATA)
+            }
+         rescue Exception => err
+            @exception = err
+         else
+            if array[0] == @data
+               bool = true
+            end
+         ensure
+            udp.close if udp
+         end
+
+         # There is no duration if the ping failed
+         @duration = Time.now - start_time if bool
+
+         bool
+      end
+
+      alias ping? ping
+      alias pingecho ping
+   end
+
+   # Class alias for backwards compatibility
+   PingUDP = Ping::UDP
+end

data/test/tc_pingexternal.rb

@@ -11,26 +11,26 @@ if base == "test" || base =~ /net-pingsimple.*/
 end
 
 require "test/unit"
-require "net/ping"
+require "net/ping/external"
 include Net
 
 class TC_PingExternal < Test::Unit::TestCase
    def setup
       @host  = "www.ruby-lang.org"
       @bogus = "foo.bar.baz"
-      @pe    = PingExternal.new(@host)
-      @bad   = PingExternal.new(@bogus)
+      @pe    = Ping::External.new(@host)
+      @bad   = Ping::External.new(@bogus)
    end
 
    def test_version
-      assert_equal("1.1.1", PingExternal::VERSION, "Bad version constant")
+      assert_equal("1.2.0", PingExternal::VERSION)
    end
    
    def test_ping
       assert_respond_to(@pe, :ping)
       assert_respond_to(@pe, :ping?)
       assert_nothing_raised{ @pe.ping }
-      assert_raises(ArgumentError){ @pe.ping(@host) }
+      assert_nothing_raised{ @pe.ping(@host) }
    end
 
    def test_good_ping     
@@ -42,14 +42,39 @@ class TC_PingExternal < Test::Unit::TestCase
       assert_equal(false, @bad.exception.nil?, "Bad exception data")
    end
 
-   def test_accessors
+   def test_duration
+      assert_nothing_raised{ @pe.ping }
+      assert_respond_to(@pe, :duration)
+      assert_kind_of(Float, @pe.duration)
+   end
+
+   def test_host
       assert_respond_to(@pe, :host)
       assert_respond_to(@pe, :host=)
+      assert_equal('www.ruby-lang.org', @pe.host)
+   end
+
+   def test_port
       assert_respond_to(@pe, :port)
       assert_respond_to(@pe, :port=)
+      assert_equal(7, @pe.port)
+   end
+
+   def test_timeout
       assert_respond_to(@pe, :timeout)
       assert_respond_to(@pe, :timeout=)
+      assert_equal(5, @pe.timeout)
+   end
+
+   def test_exception
       assert_respond_to(@pe, :exception)
+      assert_nothing_raised{ @pe.ping }
+      assert_nothing_raised{ @bad.ping }
+      assert_nil(@pe.exception)
+      assert_not_nil(@bad.exception)
+   end
+
+   def test_warning
       assert_respond_to(@pe, :warning)
    end
 

data/test/tc_pinghttp.rb

@@ -11,18 +11,18 @@ if base == "test" || base =~ /net-pingsimple.*/
 end
 
 require "test/unit"
-require "net/ping"
+require "net/ping/http"
 include Net
 
 class TC_PingHTTP < Test::Unit::TestCase
    def setup
       @uri  = "http://www.pragmaticprogrammer.com/index.html"
-      @http = PingHTTP.new(@uri)      
-      @bad  = PingHTTP.new("http://www.blabfoobarurgh.com")
+      @http = Ping::HTTP.new(@uri)      
+      @bad  = Ping::HTTP.new("http://www.blabfoobarurgh.com") # One hopes not
    end
 
    def test_version
-      assert_equal("1.1.1", PingHTTP::VERSION, "Bad version constant")
+      assert_equal("1.2.0", PingHTTP::VERSION)
    end
    
    def test_ping
@@ -38,17 +38,42 @@ class TC_PingHTTP < Test::Unit::TestCase
       assert_not_nil(@bad.exception)
    end
 
-   def test_accessors
+   def test_duration
+      assert_nothing_raised{ @http.ping }
+      assert_respond_to(@http, :duration)
+      assert_kind_of(Float, @http.duration)
+   end
+
+   def test_host
       assert_respond_to(@http, :host)
       assert_respond_to(@http, :host=)
+      assert_respond_to(@http, :uri)   # Alias
+      assert_respond_to(@http, :uri=)  # Alias
+      assert_equal('http://www.pragmaticprogrammer.com/index.html', @http.host)
+   end
+
+   def test_port
       assert_respond_to(@http, :port)
       assert_respond_to(@http, :port=)
+      assert_equal(80, @http.port)
+   end
+
+   def test_timeout
       assert_respond_to(@http, :timeout)
       assert_respond_to(@http, :timeout=)
+      assert_equal(5, @http.timeout)
+   end
+
+   def test_exception
       assert_respond_to(@http, :exception)
+      assert_nothing_raised{ @http.ping }
+      assert_nothing_raised{ @bad.ping }
+      assert_nil(@http.exception)
+      assert_not_nil(@bad.exception)
+   end
+
+   def test_warning
       assert_respond_to(@http, :warning)
-      assert_respond_to(@http, :uri)
-      assert_respond_to(@http, :uri=)
    end
 
    def teardown

data/test/tc_pingicmp.rb

@@ -0,0 +1,84 @@
+#######################################################################
+# tc_pingicmp.rb
+#
+# Test case for the Net::PingICMP class.  You must run this test case
+# with root privileges on UNIX systems.
+#######################################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /net-pingsimple.*/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+end
+
+require "test/unit"
+require "net/ping/icmp"
+include Net
+
+class TC_PingICMP < Test::Unit::TestCase
+   def setup
+      @host = "www.ruby-lang.org"
+      @icmp = Ping::ICMP.new(@host)
+   end
+
+   def test_version
+      assert_equal("1.2.0", PingICMP::VERSION)
+   end
+   
+   def test_ping
+      assert_respond_to(@icmp, :ping)
+      assert_respond_to(@icmp, :ping?)
+      assert_nothing_raised{ @icmp.ping }
+      assert_nothing_raised{ @icmp.ping(@host) }
+   end
+
+   def test_bind
+      assert_respond_to(@icmp, :bind)
+      assert_nothing_raised{ @icmp.bind(Socket.gethostname) }
+      assert_nothing_raised{ @icmp.bind(Socket.gethostname, 80) }
+   end
+
+   def test_duration
+      assert_nothing_raised{ @icmp.ping }
+      assert_respond_to(@icmp, :duration)
+      assert_kind_of(Float, @icmp.duration)
+   end
+
+   def test_duration
+      assert_nothing_raised{ @icmp.ping }
+      assert_respond_to(@icmp, :duration)
+      assert_kind_of(Float, @icmp.duration)
+   end
+
+   def test_host
+      assert_respond_to(@icmp, :host)
+      assert_respond_to(@icmp, :host=)
+      assert_equal('www.ruby-lang.org', @icmp.host)
+   end
+
+   def test_port
+      assert_respond_to(@icmp, :port)
+      assert_equal(nil, @icmp.port)
+   end
+
+   def test_timeout
+      assert_respond_to(@icmp, :timeout)
+      assert_respond_to(@icmp, :timeout=)
+      assert_equal(5, @icmp.timeout)
+   end
+
+   def test_exception
+      assert_respond_to(@icmp, :exception)
+      assert_nothing_raised{ @icmp.ping }
+      assert_nil(@icmp.exception)
+   end
+
+   def test_warning
+      assert_respond_to(@icmp, :warning)
+   end
+
+   def teardown
+      @host = nil
+      @icmp = nil
+   end
+end

data/test/tc_pingtcp.rb

@@ -11,24 +11,24 @@ if base == "test" || base =~ /net-pingsimple.*/
 end
 
 require "test/unit"
-require "net/ping"
+require "net/ping/tcp"
 include Net
 
 class TC_PingTCP < Test::Unit::TestCase
    def setup
       @host  = "www.ruby-lang.org"
-      @tcp   = PingTCP.new(@host, "http")
+      @tcp   = Ping::TCP.new(@host)
    end
 
    def test_version
-      assert_equal("1.1.1", PingTCP::VERSION, "Bad version constant")
+      assert_equal("1.2.0", PingTCP::VERSION, "Bad version constant")
    end
    
    def test_ping
       assert_respond_to(@tcp, :ping)
       assert_respond_to(@tcp, :ping?)
       assert_nothing_raised{ @tcp.ping }
-      assert_raises(ArgumentError){ @tcp.ping(@host) }
+      assert_nothing_raised{ @tcp.ping(@host) }
    end
 
    def test_ping_ecr_false
@@ -52,14 +52,38 @@ class TC_PingTCP < Test::Unit::TestCase
       assert_raises(ArgumentError){ PingTCP.ecr = "blah" }
    end
    
-   def test_accessors
+   def test_duration
+      assert_nothing_raised{ @tcp.ping }
+      assert_respond_to(@tcp, :duration)
+      assert_kind_of(Float, @tcp.duration)
+   end
+
+   def test_host
       assert_respond_to(@tcp, :host)
       assert_respond_to(@tcp, :host=)
+      assert_equal('www.ruby-lang.org', @tcp.host)
+   end
+
+   def test_port
       assert_respond_to(@tcp, :port)
       assert_respond_to(@tcp, :port=)
+      assert_equal(7, @tcp.port)
+   end
+
+   def test_timeout
       assert_respond_to(@tcp, :timeout)
       assert_respond_to(@tcp, :timeout=)
+      assert_equal(5, @tcp.timeout)
+   end
+
+   def test_exception
+      msg = "+this test may fail depending on your network environment+"
       assert_respond_to(@tcp, :exception)
+      assert_nothing_raised{ @tcp.ping }
+      assert_nil(@tcp.exception, msg)
+   end
+
+   def test_warning
       assert_respond_to(@tcp, :warning)
    end
 

data/test/tc_pingudp.rb

@@ -14,41 +14,67 @@ if base == "test" || base =~ /net-pingsimple.*/
 end
 
 require "test/unit"
-require "net/ping"
+require "net/ping/udp"
 include Net
 
 class TC_PingUDP < Test::Unit::TestCase
    def setup
       @host = "www.ruby-lang.org"
-      @udp  = PingUDP.new(@host)
+      @udp  = Ping::UDP.new(@host)
    end
 
    def test_version
-      assert_equal("1.1.1", PingUDP::VERSION, "Bad version constant")
+      assert_equal("1.2.0", PingUDP::VERSION)
    end
    
    def test_ping
       assert_respond_to(@udp, :ping)
       assert_respond_to(@udp, :ping?)
       assert_nothing_raised{ @udp.ping }
-      assert_raises(ArgumentError){ @udp.ping(@host) }
+      assert_nothing_raised{ @udp.ping(@host) }
    end
 
    def test_ping_standard
       assert_equal(false, @udp.ping?)
       assert_equal(false, @udp.exception.nil?, "Bad exception data")
    end
+
+   def test_bind
+      assert_respond_to(@udp, :bind)
+      assert_nothing_raised{ @udp.bind('www.ruby-lang.org', 80) }
+   end
    
-   def test_accessors
+   def test_duration
+      assert_nothing_raised{ @udp.ping }
+      assert_respond_to(@udp, :duration)
+      assert_kind_of(Float, @udp.duration)
+   end
+
+   def test_host
       assert_respond_to(@udp, :host)
       assert_respond_to(@udp, :host=)
+      assert_equal('www.ruby-lang.org', @udp.host)
+   end
+
+   def test_port
       assert_respond_to(@udp, :port)
       assert_respond_to(@udp, :port=)
+      assert_equal(7, @udp.port)
+   end
+
+   def test_timeout
       assert_respond_to(@udp, :timeout)
       assert_respond_to(@udp, :timeout=)
-      assert_respond_to(@udp, :data)
-      assert_respond_to(@udp, :data=)
+      assert_equal(5, @udp.timeout)
+   end
+
+   def test_exception
       assert_respond_to(@udp, :exception)
+      assert_nothing_raised{ @udp.ping }
+      assert_nil(@udp.exception)
+   end
+
+   def test_warning
       assert_respond_to(@udp, :warning)
    end