onlooker 0.1.1

data/README

@@ -0,0 +1,46 @@
+Onlooker v0.1
+=============
+
+OnLooker is a simple rails plugin that lets a user check the status of his or her website or server. OnLooker uses Ping's to check via TCP or HTTP whether the site, sites or servers that you specify are online and accessible. OnLooker also supports custom images to distinguish status.
+
+
+Example
+=======
+
+To use this plugin, simply call the check function in your controller such as:
+
+For a Website: @status = OnLooker.check('www.rubyonrails.com', 'web')
+
+For an IP: @status = OnLooker.check('207.179.66.134', 'ip')
+
+Then in your views:
+
+<%= @status %>
+
+This will report the text "Online" or "Offline" depending on the result of the check.
+
+The available options for OnLooker.check are:
+
+	- OnLooker.check(host, type, debug)
+		- Host can be a URL (without the http://) or IP
+		- Type can be set to web or ip
+		- Debug can be true or false in which OnLooker will attempt to give an explanation if your site is down
+		
+		
+Using images to distinguish statuses:
+
+OnLooker includes a basic helper to allow you to set an image for displaying online or offline status.
+
+For example, If you call the OnLooker.check function from the @status variable in your controller, your views can look something like this:
+
+<%= onlooker_format @status, :online_img => "/images/online.gif", :offline_img => "/images/offline.gif" %>
+
+That way an image is displayed in-place of the default "Online" or "Offline" text.
+
+
+Credits
+=======
+
+Copyright (c) 2008 Eric A. released under the MIT license
+http://from.two2twelve.com
+http://plugins.two2twelve.com

data/lib/net/ping.rb

@@ -0,0 +1,11 @@
+# By doing a "require 'net/ping'" you are requiring every subclass.  If you
+# want to require a specific ping type only, do "require 'net/ping/tcp'",
+# for example.
+#
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'ping/tcp'
+require 'ping/udp'
+require 'ping/icmp'
+require 'ping/external'
+require 'ping/http'

data/lib/net/ping/external.rb

@@ -0,0 +1,107 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+
+if RUBY_PLATFORM.match('mswin')
+   require 'win32/open3'
+   require 'windows/console'
+   include Windows::Console
+else
+   require 'open3'            
+end
+
+module Net
+   class Ping::External < Ping
+   
+      # Pings the host using your system's ping utility and checks for any
+      # errors or warnings.  Returns true if boolful, or false if not.
+      # 
+      # If false, then the Ping::External#exception method should contain a
+      # string indicating what went wrong.  If true, the Ping::External#warning
+      # method may or may not contain a value.
+      # 
+      def ping(host = @host)
+         super(host)
+
+         input, output, error = ""
+         pstring = "ping "
+         bool    = false
+         orig_cp = nil
+         
+         case RUBY_PLATFORM
+            when /linux|bsd|osx|mach|darwin/i
+               pstring += "-c 1 #{host}"
+            when /solaris|sunos/i
+               pstring += "#{host} 1"
+            when /hpux/i
+               pstring += "#{host} -n 1"
+            when /win32|windows|mswin/i
+               orig_cp = GetConsoleCP()
+               SetConsoleCP(437) if orig_cp != 437 # United States
+               pstring += "-n 1 #{host}"
+            else
+               pstring += "#{host}"
+         end
+         
+         start_time = Time.now
+         
+         begin
+           e = nil
+           Timeout.timeout(@timeout){
+              input, output, error = Open3.popen3(pstring)
+              e = error.gets # Can't chomp yet, might be nil
+           }
+
+           input.close
+           error.close
+
+           if RUBY_PLATFORM.match('mswin') && GetConsoleCP() != orig_cp
+              SetConsoleCP(orig_cp)
+           end
+        
+           unless e.nil?
+              if e =~ /warning/i
+                 @warning = e.chomp
+                 bool = 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?
+                 bool = true
+              else
+                 regexp = /
+                    no\ answer|
+                    host\ unreachable|
+                    could\ not\ find\ host|
+                    request\ timed\ out|
+                    100%\ packet\ loss
+                 /ix
+                 lines.each{ |e|
+                    if regexp.match(e)
+                       @exception = e.chomp
+                       break
+                    end
+                 }
+                 bool = true unless @exception
+              end
+           end
+         rescue Exception => err
+           @exception = err.message 
+         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.
+   PingExternal = Ping::External
+end

data/lib/net/ping/http.rb

@@ -0,0 +1,88 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+require 'net/http'
+require 'uri'
+
+# Force non-blocking Socket.getaddrinfo on Unix systems. Do not use on
+# Windows because it causes problems.
+unless RUBY_PLATFORM.match('mswin')
+   require 'resolv-replace'
+end
+
+module Net
+   class Ping::HTTP < Ping
+      
+      # By default an http ping will follow a redirect and give you the result
+      # of the final URI.  If this value is set to false, then it will not
+      # follow a redirect and will return false immediately on a redirect.
+      # 
+      attr_accessor :follow_redirect
+      
+      # Creates and returns a new Ping::HTTP object.  Note that the default
+      # port for Ping::HTTP is 80.
+      # 
+      def initialize(uri=nil, port=80, timeout=5)
+         @follow_redirect = true
+         super(uri, port, timeout)
+      end
+
+      # Looks for an HTTP response from the URI passed to the constructor.
+      # If the result is a kind of Net::HTTPSuccess then the ping was
+      # boolful and true is returned.  Otherwise, false is returned
+      # and the Ping::HTTP#exception method should contain a string
+      # indicating what went wrong.
+      # 
+      # If the HTTP#follow_redirect accessor is set to true (which it is
+      # by default) and a redirect occurs during the ping, then the
+      # HTTP#warning attribute is set to the redirect message, but the
+      # return result is still true.  If it's set to false then a false
+      # value is returned if a redirect occurs.
+      # 
+      def ping(host = @host)
+         super(host)
+         bool = false
+         uri = URI.parse(host)
+
+         start_time = Time.now
+
+         begin
+            response = nil
+            Timeout.timeout(@timeout){
+               response = Net::HTTP.get_response(uri.host, uri.path, @port)
+            }
+         rescue Exception => err
+            @exception = err.message
+         else
+            if response.is_a?(Net::HTTPSuccess)
+               bool = true
+            else
+               if @follow_redirect
+                  @warning = response.message
+                  while response.is_a?(Net::HTTPRedirection)
+                     redirect = URI.parse(response['location']) 
+                     redirect = uri + redirect if redirect.relative?                     
+                     response = Net::HTTP.get_response(redirect.host, redirect.path, @port)
+                  end
+                  bool = true if response.is_a?(Net::HTTPSuccess)   
+               else
+                  @exception = response.message
+               end
+            end
+         end
+
+         # There is no duration if the ping failed
+         @duration = Time.now - start_time if bool
+
+         bool
+      end
+
+      alias ping? ping
+      alias pingecho ping
+      alias follow_redirect? follow_redirect
+      alias uri host
+      alias uri= host=
+   end
+
+   # Class alias for backwards compatibility
+   PingHTTP = Ping::HTTP
+end

data/lib/net/ping/icmp.rb

@@ -0,0 +1,165 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+
+module Net
+   class Ping::ICMP < Ping   
+      ICMP_ECHOREPLY = 0
+      ICMP_ECHO      = 8
+      ICMP_SUBCODE   = 0
+      
+      # You cannot set or change the port value.  A value of 0 is always
+      # used internally for ICMP pings.
+      #
+      undef_method :port=
+
+      # Returns the data size, i.e. number of bytes sent on the ping. The
+      # default size is 56.
+      #
+      attr_reader :data_size
+
+      # Creates and returns a new Ping::ICMP object.  This is similar to its
+      # superclass constructor, but must be created with root privileges (on
+      # UNIX systems), and the port value is ignored.
+      #
+      def initialize(host=nil, port=nil, timeout=5)
+         raise 'requires root privileges' if Process.euid > 0
+
+         @seq = 0
+         @bind_port = 0
+         @bind_host = nil
+         @data_size = 56
+         @data = ''
+
+         0.upto(@data_size){ |n| @data << (n % 256).chr }
+
+         @pid  = Process.pid & 0xffff
+
+         super(host, port, timeout)
+         @port = nil # This value is not used in ICMP pings.
+      end
+
+      # Sets the number of bytes sent in the ping method.
+      #
+      def data_size=(size)
+         @data_size = size
+         @data = ''
+         0.upto(size){ |n| @data << (n % 256).chr }
+      end
+
+      # Associates the local end of the socket connection with the given
+      # +host+ and +port+.  The default port is 0.
+      #
+      def bind(host, port = 0)
+         @bind_host = host
+         @bind_port = port
+      end
+      
+      # Pings the +host+ specified in this method or in the constructor.  If a
+      # host was not specified either here or in the constructor, an
+      # ArgumentError is raised.
+      #
+      def ping(host = @host)
+         super(host)
+         bool = false
+
+         socket = Socket.new(
+            Socket::PF_INET,
+            Socket::SOCK_RAW,
+            Socket::IPPROTO_ICMP
+         )
+
+         if @bind_host
+            saddr = Socket.pack_sockaddr_in(@bind_port, @bind_host)
+            socket.bind(saddr)
+         end
+         
+         @seq = (@seq + 1) % 65536
+         pstring = 'C2 n3 A' << @data_size.to_s
+         timeout = @timeout
+
+         checksum = 0
+         msg = [ICMP_ECHO, ICMP_SUBCODE, checksum, @pid, @seq, @data].pack(pstring)
+         checksum = checksum(msg)
+         msg = [ICMP_ECHO, ICMP_SUBCODE, checksum, @pid, @seq, @data].pack(pstring)
+
+         start_time = Time.now
+
+         begin
+            saddr = Socket.pack_sockaddr_in(0, host)
+         rescue Exception
+	         return bool
+         end
+
+         socket.send(msg, 0, saddr) # Send the message
+
+         begin
+            Timeout.timeout(@timeout){
+               io_array = select([socket], nil, nil, timeout)
+
+               if io_array.nil? || io_array[0].empty?
+                  return false
+               end
+
+               pid = nil
+               seq = nil
+
+               data, sender  = socket.recvfrom(1500)
+               port, host    = Socket.unpack_sockaddr_in(sender)
+               type, subcode = data[20, 2].unpack('C2')
+
+               case type
+                  when ICMP_ECHOREPLY
+                     if data.length >= 28
+                        pid, seq = data[24, 4].unpack('n3')
+                     end
+                  else
+                     if data.length > 56
+                        pid, seq = data[52, 4].unpack('n3')
+                     end
+               end
+
+               if pid == @pid && seq == @seq && type == ICMP_ECHOREPLY
+                  bool = true
+               end
+            }
+         rescue Exception => err
+            @exception = err
+         ensure
+            socket.close if socket
+         end
+         
+         # There is no duration if the ping failed
+         @duration = Time.now - start_time if bool
+
+         return bool
+      end
+
+      alias ping? ping
+      alias pingecho ping
+
+      private
+
+      # Perform a checksum on the message.  This is the sum of all the short
+      # words and it folds the high order bits into the low order bits.
+      #
+      def checksum(msg)
+         length    = msg.length
+         num_short = length / 2
+         check     = 0
+
+         msg.unpack("n#{num_short}").each do |short|
+            check += short
+         end
+
+         if length % 2 > 0
+            check += msg[length-1, 1].unpack('C') << 8
+         end
+
+         check = (check >> 16) + (check & 0xffff)
+         return (~((check >> 16) + check) & 0xffff)
+      end   
+   end
+   
+   # Alias for consistency with other ping related classes
+   PingICMP = Ping::ICMP
+end

data/lib/net/ping/ping.rb

@@ -0,0 +1,81 @@
+require 'socket'
+require 'timeout'
+
+module Net
+   class Ping
+      VERSION = '1.2.2'
+
+      # The host to ping.  In the case of Ping::HTTP, this is the URI.
+      attr_accessor :host
+
+      # The port to ping.  This is set to the echo port (7) by default. The
+      # Ping::HTTP class defaults to port 80.
+      #
+      attr_accessor :port
+
+      # The maximum time a ping attempt is made.
+      attr_accessor :timeout
+
+      # If a ping fails, this value is set to the error that occurred which
+      # caused it to fail.
+      #
+      attr_reader :exception
+
+      # This value is set if a ping succeeds, but some other condition arose
+      # during the ping attempt which merits warning, e.g a redirect in the
+      # case of Ping::HTTP#ping.
+      #
+      attr_reader :warning
+
+      # The number of seconds (returned as a Float) that it took to ping
+      # the host. This is not a precise value, but rather a good estimate
+      # since there is a small amount of internal calculation that is added
+      # to the overall time.
+      #
+      attr_reader :duration
+
+      # The default constructor for the Net::Ping class.  Accepts an optional
+      # +host+, +port+ and +timeout+.  The port defaults to your echo port, or
+      # 7 if that happens to be undefined.  The default timeout is 5 seconds.
+      # 
+      # The host, although optional in the constructor, must be specified at
+      # some point before the Net::Ping#ping method is called, or else an
+      # ArgumentError will be raised.
+      #
+      # Yields +self+ in block context.
+      #
+      # This class is not meant to be instantiated directly.  It is strictly
+      # meant as an interface for subclasses.
+      #
+      def initialize(host=nil, port=nil, timeout=5)
+         @host      = host
+         @port      = port || Socket.getservbyname('echo') || 7
+         @timeout   = timeout
+         @exception = nil
+         @warning   = nil
+         @duration  = nil
+
+         yield self if block_given?
+      end
+      
+      # The default interface for the Net::Ping#ping method.  Each subclass
+      # should call super() before continuing with their own implementation in
+      # order to ensure that the @exception and @warning instance variables
+      # are reset.
+      #
+      # If +host+ is nil here, then it will use the host specified in the
+      # constructor.  If the +host+ is nil and there was no host specified
+      # in the constructor then an ArgumentError is raised.
+      #--
+      # The @duration should be set in the subclass' ping method.
+      #
+      def ping(host = @host)
+         raise ArgumentError, 'no host specified' unless host
+         @exception = nil
+         @warning   = nil
+      end
+      
+      alias ping? ping
+      alias pingecho ping
+   end
+end

data/lib/net/ping/tcp.rb

@@ -0,0 +1,86 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+
+module Net
+
+   # With a TCP ping, simply try to open a connection.  If we are successful,
+   # assume bool.  In either case, close the connection to be polite.
+   #
+   class Ping::TCP < Ping
+      @@service_check = false
+
+      # Returns whether or not Errno::ECONNREFUSED is considered a successful
+      # ping. The default is false.
+      # 
+      def self.service_check
+         @@service_check
+      end
+
+      # Sets whether or not an Errno::ECONNREFUSED should be considered a
+      # successful ping.
+      # 
+      def self.service_check=(bool)
+         unless bool.kind_of?(TrueClass) || bool.kind_of?(FalseClass)
+            raise ArgumentError, 'argument must be true or false'
+         end
+         @@service_check = bool
+      end
+
+      # This method attempts to ping a host and port using a TCPSocket with
+      # the host, port and timeout values passed in the constructor.  Returns
+      # true if successful, or false otherwise.
+      # 
+      # Note that, by default, an Errno::ECONNREFUSED return result will be
+      # considered a failed ping.  See the documentation for the
+      # Ping::TCP.service_check= method if you wish to change this behavior.
+      # 
+      def ping(host=@host)
+         super(host)
+
+         bool = false
+         tcp = nil
+         start_time = Time.now
+
+         begin
+            Timeout.timeout(@timeout){
+               begin
+                  tcp = TCPSocket.new(host, @port)
+               rescue Errno::ECONNREFUSED => err
+                  if @@service_check
+                     bool = true
+                  else
+                     @exception = err
+                  end
+               rescue Exception => err
+                  @exception = err
+               else
+                  bool = true
+               end
+            }
+         rescue Timeout::Error => err
+            @exception = err
+         ensure
+            tcp.close if tcp
+         end
+
+         # There is no duration if the ping failed
+         @duration = Time.now - start_time if bool
+
+         bool
+      end
+
+      alias ping? ping
+      alias pingecho ping
+      
+      # Class method aliases. DEPRECATED.
+      class << self
+         alias econnrefused service_check
+         alias econnrefused= service_check=
+         alias ecr service_check
+         alias ecr= service_check=         
+      end
+   end
+
+   # Class alias for backwards compatibility
+   PingTCP = Ping::TCP
+end

data/lib/net/ping/udp.rb

@@ -0,0 +1,119 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'ping'
+
+module Net
+   class Ping::UDP < Ping
+      @@service_check = true
+      
+      # Returns whether or not the connect behavior should enforce remote
+      # service availability as well as reachability. The default is true.
+      #
+      def self.service_check
+         @@service_check
+      end
+      
+      # Set whether or not the connect behavior should enforce remote
+      # service availability as well as reachability. If set to false
+      # then Errno::ECONNREFUSED or Errno::ECONNRESET will be considered
+      # a successful ping, meaning no actual data handshaking is required.
+      # By default, if either of those errors occurs it is considered a failed
+      # ping.
+      #
+      def self.service_check=(bool)
+         unless bool.kind_of?(TrueClass) || bool.kind_of?(FalseClass)
+            raise ArgumentError, 'argument must be true or false'
+         end
+         @@service_check = bool         
+      end
+      
+      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 Errno::ECONNREFUSED, Errno::ECONNRESET => err
+            if @@service_check
+               @exception = err
+            else
+               bool = true
+            end
+         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/lib/onlooker.rb

@@ -0,0 +1,48 @@
+require "net/ping"
+include Net
+class OnLooker
+  
+  def self.check(host, ping_type, debug=false, timeout=2)
+    type = ping_type.downcase
+    if type == "ip"
+      request = Net::PingExternal.new(host, timeout)
+      get_result(request, debug)
+    elsif type == "web"
+      request = PingTCP.new(host, "http", 2)
+      get_result(request, debug)
+    else
+      "Type invalid. Try 'web' or 'ip'."
+    end    
+  end
+  
+  def self.get_result(request, debug)
+    if request.ping?
+        "Online"
+    else
+        status = "Offline "
+        if debug == true
+          return status + request.exception
+        else
+          return status
+        end
+    end
+  end
+  
+end
+
+module OnLookerHelper
+  
+  def onlooker_format(status, *params)
+    options = params.extract_options!.symbolize_keys
+    
+    options[:online_img] ||= options.include?(:online_img)
+    options[:offline_img] ||= options.include?(:offline_img)
+    
+    if status == "Online"
+      "<img src='#{options[:online_img]}' alt='Online' />"
+    else
+      "<img src='#{options[:offline_img]}' alt='Offline' />"
+    end
+  end
+  
+end

data/test/onlooker_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class OnlookerTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: onlooker
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Jonathan Towell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-24 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: |-
+  OnLooker is a simple rails plugin that lets a user check the status of his or her website or server. OnLooker uses 
+    Ping's to check via TCP or HTTP whether the site, sites or servers that you specify are online and accessible. OnLooker 
+    also supports custom images to distinguish status.
+email: jrtowell@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/net/ping/external.rb
+- lib/net/ping/http.rb
+- lib/net/ping/icmp.rb
+- lib/net/ping/ping.rb
+- lib/net/ping/tcp.rb
+- lib/net/ping/udp.rb
+- lib/net/ping.rb
+- lib/onlooker.rb
+- README
+has_rdoc: true
+homepage: http://github.com/jrtowell/onlooker
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: OnLooker is a simple rails plugin that lets a user check the status of his or her website or server. OnLooker uses  Ping's to check via TCP or HTTP whether the site, sites or servers that you specify are online and accessible. OnLooker  also supports custom images to distinguish status.
+test_files: 
+- test/onlooker_test.rb