net-ping 1.0.0

data/CHANGES

@@ -0,0 +1,67 @@
+== 1.0.0 - 14-Jun-2005
+* Renamed project from net-pingsimple to just net-ping.
+* Added a PingHTTP subclass.
+* Moved project to RubyForge.
+* Added a gemspec.
+
+== 0.3.1 - 9-Apr-2005
+* Updated PingExternal to use win32/open3 on Win32 platforms.
+* Minor error handling change for the PingSimple.econnrefused= method.  It now
+  raises an ArgumentError if any values other than true or false are passed.
+* PingSimple#warning and PingSimple#exception are now read-only methods.
+* The warning and exception attributes are now reset to nil between each call
+  to ping.
+* The data and data= methods are now unique to the PingUDP class.
+* The time and time= methods have been changed to timeout and timeout=,
+  respectively.
+* Removed the pingsimple.rd and pingsimple.html files.  The pingsimple.txt file
+  has been reorganized and is now rdoc friendly.
+* Added a few sample programs under the 'examples' directory.
+* Some minor test updates and changes.
+* Removed the INSTALL file.  That information is now in the README file.
+* Now requires Ruby 1.8.0 or later.
+
+== 0.3.0 - 12-Feb-2004
+* Fixed ping string for PingExternal class based on platform.  The old
+  string was really only good for Linux and *BSD.
+* Added Win32 support (requires win32_popen package).
+* Added warranty info.
+
+== 0.2.3 - 12-Aug-2003
+* Fixed a bug in PingExternal that could consume file descriptors if used in a loop
+* Added some initialization to avoid -w warnings
+* Removed VERSION() class method.  Use the constant instead
+* Modified test suite slightly
+* Moved rd2 docs to doc directory
+
+== 0.2.2 - 3-Apr-2003
+* Fixed handling of stdout in PingExternal
+
+== 0.2.1 - 27-Mar-2003
+* Fixed major bug with PingExternal class with regards to down hosts
+* Exceptions and warnings from PingExternal are now chomp'd
+* Modified test suite
+* Doc updates
+
+== 0.2.0 - 14-Feb-2003
+* The default behavior of PingTCP with regards to ECONNREFUSED is now 
+  configurable
+* Added a VERSION constant and method (to the base class)
+* Added a test suite (for those with testunit installed)
+* Doc changes, rearrangement and general cleanup
+* Manifest is now MANIFEST
+* Added an INSTALL file
+
+== 0.1.0 - 9-Dec-2002
+* Added ping? alias for ping method
+* Warnings now handled separately
+* Corrected a mis-named variable in Ping::External
+* Fixed the install.rb file
+* Updated and added docs
+* Renamed tarball to net-pingsimple to reflect RAA naming convention
+
+== 0.0.1a
+* Did this release ever happen?
+
+== 0.0.1
+* Initial release.

data/MANIFEST

@@ -0,0 +1,17 @@
+MANIFEST
+CHANGES
+README
+test.rb
+install.rb
+
+examples/test_pingexternal.rb
+examples/test_pinghttp.rb
+examples/test_pingtcp.rb
+examples/test_pingudp.rb
+
+net/pingsimple.rb
+
+test/tc_pingexternal.rb
+test/tc_pingtcp.rb
+test/tc_pingudp.rb
+test/tc_pinghttp.rb

data/README

@@ -0,0 +1,20 @@
+== Description
+   A simple Ruby interface to the 'ping' command
+
+== Prerequisites
+   * Ruby 1.8.0 or later
+   * The win32/open3 package is required for Win32 systems.
+
+== Installation
+=== Manual Installation
+   ruby test.rb (optional)
+   ruby install.rb
+=== Gem Installation
+   ruby net-ping.gemspec
+   gem install net-ping-<version>.gem
+
+== Notes
+   Please read the documentation.  Especially pay attention to the docs
+   pertaining to ECONNREFUSED with regards to TCP pings.
+
+   Also note the documentation regarding down hosts.

data/doc/ping.txt

@@ -0,0 +1,205 @@
+== Description
+   A simple Ruby interface to the 'ping' command.
+
+== Synopsis
+   require "net/ping"
+   include Net
+
+   PingTCP.econnrefused = true
+
+   pt = Net::PingTCP.new(host)
+   pu = Net::PingUDP.new(host)
+   pe = Net::PingExternal.new(host)
+   ph = Net::PingHTTP.new(uri)
+
+   if pt.ping
+      puts "TCP ping successful"
+   else
+      puts "TCP ping unsuccessful: " +  pt.exception
+   end
+
+   if pu.ping
+      puts "UDP ping successful"
+   else
+      puts "UDP ping unsuccessful: " +  pu.exception
+   end
+
+   if pe.ping
+      puts "External ping successful"
+   else
+      puts "External ping unsuccessful: " +  pe.exception
+   end
+
+   if ph.ping?
+      puts "HTTP ping successful"
+   else
+      puts "HTTP ping unsuccessful: " + ph.exception
+   end
+
+== Ping Classes
+   * PingTCP
+   * PingUDP
+   * PingExternal
+   * PingHTTP
+
+   All Ping classes are children of the Ping parent class (which should
+   never be instantiated directly).
+
+=== PingTCP
+PingTCP.new(host, port=7, timeout=5)
+	Creates and returns a new PingTCP object.
+	
+PingTCP.econnrefused
+	Returns the setting for how ECONNREFUSED is handled.  By default, this is
+	set to false, i.e. an ECONNREFUSED error is considered a failed ping.
+	
+PingTCP.econnrefused=(bool)
+	Sets the behavior for how ECONNREFUSED is handled.  By default, this is
+	set to false, i.e. an ECONNREFUSED error is considered a failed ping.
+	
+PingTCP#ping
+PingTCP#ping?
+	Attempts to open a connection using TCPSocket.  A successful open means
+	the ping was successful and true is returned.  Otherwise, false is returned.
+
+=== PingUDP
+PingUDP.new(host, port=7, timeout=5)
+	Creates and returns a new PingUDP object.
+	
+PingUDP#ping
+PingUDP#ping?
+	Attempts to open a connection using UDPSocket and sends the value of
+	PingUDP#data as a string across the socket.  If the return string matches,
+	then the ping was successful and true is returned.  Otherwise, false is
+	returned.
+	
+PingUDP#data
+	Returns the string that is sent across the UDP socket.
+	
+PingUDP#data=(string)
+	Sets the string that is sent across the UDP socket.  The default is "ping"
+
+=== PingExternal
+PingExternal.new(host, port=7, timeout=5)
+	Creates and returns a new PingExternal object.
+	
+PingExternal#ping
+PingExternal#ping?
+	Uses the 'open3' module and calls your system's local 'ping' command with
+	various options, depending on platform.  If nothing is sent to stderr, the
+	ping was successful and true is returned.  Otherwise, false is returned.
+	
+=== PingHTTP
+PingHTTP.new(uri, port=7, timeout=5)
+	Creates and returns a new PingHTTP object.
+	
+PingHTTP#ping
+PingHTTP#ping?
+	Checks for a response against +uri+.  As long as a Net::HTTPSuccess or
+	Net::HTTPOK response is returned, the ping is successful and true is
+	returned.  Otherwise, false is returned and PingHTTP#exception is set to
+	the error message.
+	
+PingHTTP#uri
+	An alias for PingHTTP#host.
+	
+PingHTTP#uri=(uri)
+	An alias for PingHTTP#host=.
+
+== Instance Methods
+Ping#exception
+	Returns the error string that was set if a ping call failed.  If an exception
+	is raised, it is caught and stored in this attribute.  It is not raised in
+	your code.
+	
+	This should be nil if the ping succeeded.
+
+Ping#host
+	Returns the host name that ping attempts will ping against.
+
+Ping#host=(hostname)
+	Sets the host name that ping attempts will ping against.
+
+Ping#port
+	Returns the port number that ping attempts will use.
+	
+Ping#port=(port)
+	Set the port number to open socket connections on.  The default is 7 (or
+	whatever your 'echo' port is set to).  Note that you can also specify a
+	string, such as "http".
+
+Ping#timeout
+	Returns the amount of time before the timeout module raises a TimeoutError
+	during connection attempts.  The default is 5 seconds.
+	
+Ping#timeout=(time)
+	Sets the amount of time before the timeout module raises a TimeoutError.
+	during connection attempts.
+	
+Ping#warning
+	Returns a warning string that was returned during the ping attempt.  This
+	typically occurs only in the PingExternal class.
+
+== Notes
+   If a host is down *IT IS CONSIDERED A FAILED PING*, and the 'no answer from
+   +host+' text is assigned to the 'exception' attribute.  You may disagree with
+   this behavior, in which case you need merely check the exception attribute
+   against a regex as a simple workaround.
+
+== FAQ
+   Q: "Why don't you return exceptions if a connection fails?"
+
+   A: Because ping is only meant to return one of two things - success or
+      failure.  It's very simple.  If you want to find out *why* the ping
+      failed, you can check the 'exception' attribute.
+
+   Q: "I know the host is alive, but a TCP or UDP ping tells me otherwise. What
+      gives?"
+
+   A: It's possible that the echo port has been disabled on the remote
+      host for security reasons.  Your best best is to specify a different port
+      or to use PingExternal instead.
+
+   Q: "Why does TCP ping return false when I know it should return true?"
+
+   A: By default ECONNREFUSED errors will return a value of false.  This is
+      contrary to what most other folks do for TCP pings.  The problem with
+      their philosphy is that you can get false positives if a firewall blocks
+      the route to the host.  The problem with my philosophy is that you can
+      get false negatives if there is no firewall (or it's not blocking the
+      route).  Given the alternatives I chose the latter.
+
+      You can always change the default behavior by using the +econnrefused+
+      class method.
+
+   Q: "Couldn't you use traceroute information to tell for sure?"
+
+   A: I *could* but I won't so don't bug me about it.  It's far more effort than
+      it's worth.
+
+== Known Bugs
+   You may see a test failure from the tc_pingtcp test case.  You can ignore
+   this.
+
+   Please report any bugs on the project page at
+   http://www.rubyforge.org/projects/shards.
+
+== Future Plans
+   Add an PingICMP class (help wanted)
+   (Though see arton's icmpping package on the RAA)
+
+== License
+   Ruby's
+
+== Copyright
+   (C) 2003-2005 Daniel J. Berger, All Rights Reserved
+
+== Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+== Author
+   Daniel J. Berger
+   djberg96 at yahoo dot com
+   imperator on IRC (irc.freenode.net)

data/lib/net/ping.rb

@@ -0,0 +1,229 @@
+require "socket"
+require "timeout"
+
+module Net
+   # An abstract base class.  Do not instantiate directly.
+   class Ping
+      VERSION = "1.0.0"
+      attr_accessor :host, :port, :timeout
+      attr_reader :exception, :warning
+      
+      def initialize(host, port=nil, timeout=5)
+         @host    = host
+         @port    = port || Socket.getservbyname("echo") || 7
+         @timeout = timeout
+         @data    = "ping"
+         @exception = nil
+         @warning   = nil
+      end
+      
+      def ping
+         @exception = nil
+         @warning   = nil
+      end
+   end
+
+   ##########################################################################
+   # With a TCP ping, simply try to open a connection.  If we are successful,
+   # assume success.  In either case, close the connection to be polite.
+   ##########################################################################
+   class PingTCP < Ping
+      @@econnrefused = false
+
+      # Returns true if the ECONNREFUSED error is to be considered a
+      # successful ping.  The default is false.
+      def self.econnrefused
+         @@econnrefused
+      end
+
+      # An alias for PingTCP.econnrefused
+      def self.ecr
+         self.econnrefused
+      end
+
+      # Sets whether or not an ECONNREFUSED error should be considered a
+      # successful ping or not.
+      def self.econnrefused=(bool)
+         unless bool.kind_of?(TrueClass) || bool.kind_of?(FalseClass)
+            raise ArgumentError, "argument must be true or false"
+         end
+         @@econnrefused = bool
+      end
+
+      # An alias for PingTCP.econnrefused=
+      def self.ecr=(bool)
+         self.econnrefused = bool
+      end
+
+      # This method attempts to ping a host and port using a TCPSocket with
+      # the host and port values passed to the constructor. 
+      def ping
+         super
+         success = false
+         t = nil
+         begin
+            Timeout.timeout(@timeout){
+               begin
+                  t = TCPSocket.new(@host,@port)
+               rescue Errno::ECONNREFUSED => e
+                  if @@econnrefused == true
+                     success = true
+                  else
+                     @exception = e
+                  end
+               rescue Exception => e
+                  @exception = e
+               else
+                  success = true
+               end
+            }
+         rescue TimeoutError => t
+            @exception = t
+         ensure
+            t.close if t
+         end
+         success
+      end
+      
+      alias ping? ping
+   end
+   
+   ##########################################################################
+   # With a UDP ping, send a simple text string and check the return string.
+   # If they match, assume success.
+   ##########################################################################
+   class PingUDP < Ping
+      attr_accessor :data
+
+      # Sends a simple text string and checks the return string.  If they
+      # match, the ping was successful.
+      def ping
+         super
+         success = false
+         u = UDPSocket.open
+         a = []
+         begin
+            Timeout.timeout(@timeout){
+               u.connect(@host,@port)
+               u.send(@data,0)
+               a = u.recvfrom(64)
+            }
+         rescue Exception => e
+            @exception = e
+         else
+            if a[0] == @data
+               success = true
+            end
+         ensure
+            u.close if u
+         end
+         success
+      end
+      
+      alias ping? ping
+   end
+   
+   ##################################
+   # Use your system's ping command
+   ##################################
+   class PingExternal < Ping
+
+      # Pings the host using your system's ping utility and checks for any
+      # errors or warnings.
+      def ping
+         super
+         input, output, error = ""
+         pstring = "ping "
+         success = false
+         
+         case PLATFORM
+            when /linux|bsd/i
+               pstring += "-c 1 #{@host}"
+            when /solaris|sunos/i
+               pstring += "#{@host} 1"
+            when /hpux/i
+               pstring += "#{@host} -n 1"
+            when /win32|windows/i
+               pstring += "-n 1 #{@host}"
+            else
+               pstring += "#{@host}"
+         end
+         
+         if File::ALT_SEPARATOR
+            require "win32/open3"           
+         else
+            require "open3"            
+         end
+         
+         Timeout.timeout(@timeout){
+            input, output, error = Open3.popen3(pstring)
+         }
+
+         e = error.gets # Can't chomp yet, might be nil
+
+         input.close
+         error.close
+        
+         unless e.nil?
+            if e =~ /warning/i
+               @warning = e.chomp
+               success = true
+            else
+               @exception = e.chomp
+            end
+         # The "no answer" response goes to stdout, not stderr, so check it
+         else
+            lines = output.readlines
+            output.close
+            if lines.nil? || lines.empty?
+               success = true
+            else
+               regexp = /no answer|host unreachable|could not find host/i
+               lines.each{ |e|
+                  if regexp.match(e)
+                     @exception = e.chomp
+                  end
+               }
+               success = true
+            end
+         end
+         success
+      end
+      
+      alias ping? ping
+   end
+
+   # For this class, +host+ is actually a URI.
+   class PingHTTP < Ping
+      require "net/http"
+      require "uri"
+      include Net
+
+      # Looks for an HTTP response from the URI passed to the constructor.
+      # If the result is HTTPSuccess or HTTPOK, the ping was successful.
+      def ping
+         super
+         success = false
+
+         begin
+            resp = HTTP.get_response(URI.parse(@host), nil, @timeout)
+         rescue Exception => e
+            @exception = e
+         else
+            case resp
+               when Net::HTTPSuccess, Net::HTTPOK
+                  success = true
+               else
+                  @exception = resp.message
+            end
+         end
+
+         success
+      end
+
+      alias ping? ping
+      alias uri host
+      alias uri= host=
+   end
+
+end # Net

data/test/tc_pingexternal.rb

@@ -0,0 +1,62 @@
+############################################
+# tc_pingexternal.rb
+#
+# Test case for the Net::PingExternal class
+############################################
+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"
+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)
+   end
+
+   def test_version
+      assert_equal("1.0.0", PingExternal::VERSION, "Bad version constant")
+   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) }
+   end
+
+   def test_good_ping     
+      assert_equal(true, @pe.ping?)
+   end
+
+   def test_bad_ping
+      assert_equal(false, @bad.ping?)
+      assert_equal(false, @bad.exception.nil?, "Bad exception data")
+   end
+
+   def test_accessors
+      assert_respond_to(@pe, :host)
+      assert_respond_to(@pe, :host=)
+      assert_respond_to(@pe, :port)
+      assert_respond_to(@pe, :port=)
+      assert_respond_to(@pe, :timeout)
+      assert_respond_to(@pe, :timeout=)
+      assert_respond_to(@pe, :exception)
+      assert_respond_to(@pe, :warning)
+   end
+
+   def teardown
+      @host  = nil
+      @bogus = nil
+      @pe    = nil
+      @bad   = nil
+   end
+end

data/test/tc_pinghttp.rb

@@ -0,0 +1,58 @@
+#########################################
+# tc_pinghttp.rb
+#
+# Test case for the Net::PingHTTP class.
+#########################################
+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"
+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")
+   end
+
+   def test_version
+      assert_equal("1.0.0", PingHTTP::VERSION, "Bad version constant")
+   end
+   
+   def test_ping
+      assert_respond_to(@http, :ping)
+      assert_respond_to(@http, :ping?)
+      assert_nothing_raised{ @http.ping }
+      assert_raises(ArgumentError){ @http.ping(@host) }
+   end
+
+   def test_ping_success
+      assert_equal(true, @http.ping?)
+      assert_equal(false, @bad.ping?)
+      assert_not_nil(@bad.exception)
+   end
+
+   def test_accessors
+      assert_respond_to(@http, :host)
+      assert_respond_to(@http, :host=)
+      assert_respond_to(@http, :port)
+      assert_respond_to(@http, :port=)
+      assert_respond_to(@http, :timeout)
+      assert_respond_to(@http, :timeout=)
+      assert_respond_to(@http, :exception)
+      assert_respond_to(@http, :warning)
+      assert_respond_to(@http, :uri)
+      assert_respond_to(@http, :uri=)
+   end
+
+   def teardown
+      @uri  = nil
+      @http = nil
+   end
+end

data/test/tc_pingtcp.rb

@@ -0,0 +1,69 @@
+#######################################
+# tc_pingtcp.rb
+#
+# Test case for the Net::PingTCP class
+#######################################
+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"
+include Net
+
+class TC_PingTCP < Test::Unit::TestCase
+   def setup
+      @host  = "www.ruby-lang.org"
+      @tcp   = PingTCP.new(@host, "http")
+   end
+
+   def test_version
+      assert_equal("1.0.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) }
+   end
+
+   def test_ping_ecr_false
+      PingTCP.ecr = false
+      assert_equal(false, @tcp.ping?)
+      assert_equal(false, @tcp.exception.nil?, "Bad exception data")
+   end
+
+   def test_ping_ecr_true
+      msg = "+this test may fail depending on your network environment+"
+      PingTCP.ecr = true
+      assert_equal(true, @tcp.ping?, msg)
+   end
+   
+   def test_ecr
+      assert_respond_to(PingTCP, :econnrefused)
+      assert_respond_to(PingTCP, :econnrefused=)
+      assert_respond_to(PingTCP, :ecr)
+      assert_respond_to(PingTCP, :ecr=)
+      assert_raises(ArgumentError){ PingTCP.ecr = "blah" }
+   end
+   
+   def test_accessors
+      assert_respond_to(@tcp, :host)
+      assert_respond_to(@tcp, :host=)
+      assert_respond_to(@tcp, :port)
+      assert_respond_to(@tcp, :port=)
+      assert_respond_to(@tcp, :timeout)
+      assert_respond_to(@tcp, :timeout=)
+      assert_respond_to(@tcp, :exception)
+      assert_respond_to(@tcp, :warning)
+   end
+
+   def teardown
+      @host = nil
+      @tcp  = nil
+   end
+end

data/test/tc_pingudp.rb

@@ -0,0 +1,59 @@
+################################################################
+# tc_pingudp.rb
+#
+# Test case for the Net::PingUDP class
+#
+# If someone could provide me a host where a udp ping actually
+# works, I would appreciate it. :)
+################################################################
+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"
+include Net
+
+class TC_PingUDP < Test::Unit::TestCase
+   def setup
+      @host = "www.ruby-lang.org"
+      @udp  = PingUDP.new(@host)
+   end
+
+   def test_version
+      assert_equal("1.0.0", PingUDP::VERSION, "Bad version constant")
+   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) }
+   end
+
+   def test_ping_standard
+      assert_equal(false, @udp.ping?)
+      assert_equal(false, @udp.exception.nil?, "Bad exception data")
+   end
+   
+   def test_accessors
+      assert_respond_to(@udp, :host)
+      assert_respond_to(@udp, :host=)
+      assert_respond_to(@udp, :port)
+      assert_respond_to(@udp, :port=)
+      assert_respond_to(@udp, :timeout)
+      assert_respond_to(@udp, :timeout=)
+      assert_respond_to(@udp, :data)
+      assert_respond_to(@udp, :data=)
+      assert_respond_to(@udp, :exception)
+      assert_respond_to(@udp, :warning)
+   end
+
+   def teardown
+      @host = nil
+      @udp  = nil
+   end
+end

data/test/ts_ping.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(Dir.pwd + "/lib")
+$LOAD_PATH.unshift(Dir.pwd + "/test")
+
+require "tc_pingexternal"
+require "tc_pinghttp"
+require "tc_pingtcp"
+require "tc_pingudp"

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: net-ping
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2005-06-14
+summary: A ping interface for Ruby
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/shards
+rubyforge_project: 
+description: A ping interface for Ruby
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+- Daniel J. Berger
+files: 
+- lib/net/ping.rb
+- CHANGES
+- MANIFEST
+- README
+- test/tc_pingexternal.rb
+- test/tc_pinghttp.rb
+- test/tc_pingtcp.rb
+- test/tc_pingudp.rb
+- test/ts_ping.rb
+- doc/ping.txt
+test_files: 
+- test/ts_ping.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- doc/ping.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+