opticon 0.0.1

data/Manifest.txt

@@ -0,0 +1,24 @@
+Rakefile
+README.txt
+CHANGELOG.txt
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+examples/sample.rb
+lib/opticon.rb
+lib/opticon/failure.rb
+lib/opticon/http.rb
+lib/opticon/mailer.rb
+lib/opticon/mailer/failure_notification.rhtml
+lib/opticon/notifier.rb
+lib/opticon/runner.rb
+lib/opticon/service.rb
+lib/opticon/tester.rb
+lib/opticon/version.rb
+setup.rb
+test/opticon/http_test.rb
+test/opticon/mailer_test.rb
+test/opticon/tester_test.rb
+test/opticon_test.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,15 @@
+Opticon is a no-nonsense utility for monitoring HTTP-based services (websites).
+
+When triggered, opticon connects to a list of URIs and checks to make sure that
+they pass some arbitrary test, such as responding with a non-error HTTP response 
+code, or returning content that matches a regular expression. In case of failure, 
+opticon generates emails that can be forwarded to your mailbox, blackberry, 
+cellphone,  etc.
+
+
+For installation instructions and other info, visit opticon's Google Code 
+page at:
+
+  http://code.google.com/p/opticon/
+
+(Have a look at the Wiki in particular)

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'opticon', 'version')
+
+AUTHOR = "Matt Zukowski"  # can also be an array of Authors
+EMAIL = "matt [at] roughest.net"
+DESCRIPTION = "Peace of mind through automated monitoring of your HTTP services."
+GEM_NAME = "opticon" # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "opticon" # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DEPS = ['actionmailer']
+
+NAME = "opticon"
+REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (Opticon::VERSION::STRING + (REV ? ".#{REV}" : ""))
+                          CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "opticon documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/*_test.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  p.extra_deps = DEPS
+  
+  # == Optional
+  #p.changes        - A description of the release's latest changes.
+  #p.extra_deps     - An array of rubygem dependencies.
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end

data/examples/sample.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+require 'rubygems'; gem 'opticon'; require 'opticon'
+
+# Where notifications will be emailed
+SEND_TO = "sample@nowhere.foo"
+
+# If you want to send to multiple mailboxes, you can specify an array of
+# addresses like so:
+# 
+#   SEND_TO = ['robert@nowhere.foo', 'sally@nowhere.foo']
+
+# Email notifications will show up as coming from this address.
+FROM = "opticon@nowhere.foo"
+
+# You may have to set the FROM value to be a real email address (e.g. your 
+# email address). Otherwise your mail server may decide to drop Opticon's
+# notification messages.
+
+# You don't have to change anything on this next line. This configures the 
+# default notification behaviour for Opticon, which is to email failures to the
+# addresses you configured above.
+Opticon.default_notifiers = Opticon::Notifier::Email.new(SEND_TO, :from => FROM)
+
+# You may need to configure the Mailer with your mail server info. Here's how to
+# use an SMTP mail server (unless you do this, local sendmail will be used used
+# by default):
+# 
+#   Opticon::Mailer.smtp_settings = {
+#       :address => 'mail.nowhere.foo',
+#       :username => 'johnny',
+#       :password => 'topsecret'
+#     }
+# 
+# See http://api.rubyonrails.com/classes/ActionMailer/Base.html for more details
+# on setting up the mailer.
+
+# Now you can set up some tests. Note that this is just plain Ruby code, formatted
+# a bit strangely (note the dot at the end of each line -- we are calling the test()
+# method on the URI string, and then on the result of each successive test).
+# Here are some examples:
+
+"http://www.yahoo.com/".
+  # check that the HTTP response code is in the 200 range
+  test(:responds_with_code, :success).
+  # check that the page includes the string "Privacy Policy"
+  test(:response_body_contains, "Privacy Policy")  
+
+"http://google.com".
+  # Google will try to redirect to http://www.google.com/
+  test(:responds_with_code, 302) 
+  # Note that currently there is no test for checking where you are being
+  # redirected to. This functionality will be added in the future.
+
+
+# For a comprehensive guide on configuring and using Opticon, please see:
+#
+#   http://code.google.com/p/opticon/wiki/ConfiguringOpticon
+#

data/lib/opticon.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Opticon
+
+  @@default_notifiers = nil
+  def default_notifiers
+    @@default_notifiers
+  end
+  def default_notifiers=(notifiers)
+    notifiers = [notifiers] unless notifiers.kind_of? Array
+    @@default_notifiers = notifiers
+  end
+  module_function :default_notifiers, 'default_notifiers='
+  
+end
+
+require 'opticon/service'
+require 'opticon/notifier'

data/lib/opticon/failure.rb

@@ -0,0 +1,40 @@
+module Opticon
+  module Failure
+    class Base
+      attr_reader :uri, :condition, :response
+      attr_accessor :exception
+    
+      def initialize(uri, condition, response)
+        @uri = uri
+        @condition = condition
+        @response = response
+      end
+      
+      def to_s
+        "#<#{self.class} [#{uri}] #{failure_message}>"
+      end
+    end
+    
+    class ConnectionFailure < Base
+      def failure_message
+        "#{exception.message} (#{exception.class})"
+      end
+    end
+    
+    class ResponseCodeTestFailure < Base
+      def failure_message
+        "Expected response code #{condition.inspect} but got '#{response.message}' (#{response.code})"
+      end
+    end
+    
+    class ContentTestFailure < Base
+      def failure_message
+        if exception 
+          return exception.message
+        else
+          "Content did not include the expected #{condition.class} #{condition.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/opticon/http.rb

@@ -0,0 +1,39 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+module Opticon
+  module HTTP
+    def response
+      raise "URI cannot be empty" if uri.kind_of? String and (uri.nil? or uri.empty?)
+      
+      self.uri = URI.parse(self.uri) unless self.uri.kind_of? URI
+      if @response and self.uri == @last_fetched_uri
+        @response
+      else 
+        @response = get(self.uri)
+      end
+    end
+    
+    def get(get_uri)
+      if self.uri.kind_of? URI
+        get_uri = self.uri
+      else
+        get_uri = URI.parse(self.uri) unless self.uri.kind_of? URI
+      end
+      
+      @last_fetched_uri = get_uri
+      
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      
+      response = nil
+      http.start do
+        path = uri.path.empty? ? '/' : uri.path
+        response = http.request_get(path)
+      end
+      
+      response
+    end
+  end
+end

data/lib/opticon/mailer.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+
+gem 'actionmailer'
+require 'action_mailer'
+
+module Opticon
+  class Mailer < ::ActionMailer::Base
+    # we use sendmail by default since it might just work out of the box
+    # (:smtp, which is the normal default, definetly won't work without manual configuration)
+    self.delivery_method = :sendmail 
+    self.template_root = File.dirname(File.expand_path(__FILE__))+'/..'
+  
+    def failure_notification(failure, recipients, from)
+      self.recipients recipients
+      self.from       from
+      subject    "HTTP Service Failure: #{failure.uri}"
+      body       :failure => failure
+    end
+  end
+end

data/lib/opticon/mailer/failure_notification.rhtml

@@ -0,0 +1,5 @@
+Service at '<%= @failure.uri %>' failed: 
+
+<%= @failure.failure_message %>
+
+(Generated by Opticon on host '<%= ENV['HOSTNAME'] %>' at <%= Time.now %>)

data/lib/opticon/notifier.rb

@@ -0,0 +1,18 @@
+require 'opticon/mailer'
+
+module Opticon
+  module Notifier  
+    class Email
+      attr_accessor :recipients, :from
+      
+      def initialize(recipients, options = {:from => "opticon@#{ENV['HOSTNAME']}"})
+        @recipients = recipients
+        @from = options[:from]
+      end
+      
+      def notify(failure)
+        Opticon::Mailer.deliver_failure_notification(failure, recipients, from)
+      end
+    end
+  end
+end

data/lib/opticon/runner.rb

@@ -0,0 +1,4 @@
+module Opticon
+  class Runner
+  end
+end

data/lib/opticon/service.rb

@@ -0,0 +1,67 @@
+require 'uri'
+require 'opticon/tester'
+
+module Opticon
+  class Service
+    attr_accessor :notifiers
+  
+    def initialize(uri, notifiers = Opticon.default_notifiers)
+      raise ArgumentError, "You must either provide a valid Notifier or set Opticon.default_notifiers." unless
+        notifiers and (notifiers.respond_to? :notify or notifiers.first.respond_to? :notify)
+      @uri = URI.parse(uri)
+      
+      if notifiers.kind_of? Array
+        @notifiers = notifiers
+      else
+        @notifiers = [notifiers]
+      end
+    end
+    
+    def to_s
+      @uri.to_s
+    end
+    
+    def test(tester, *args)
+      case tester
+      when :responds_with_code, 'responds_with_code'
+        tester = Opticon::Tester::ResponseCodeTester.new
+      when :response_body_contains, 'response_body_contains'
+        tester = Opticon::Tester::ContentTester.new
+      when Class
+        tester = tester.new
+      when Tester::Base
+        tester = tester
+      else
+        begin
+          tester_class = "Opitcon::Tester::#{tester.to_s}".constantize
+          tester = tester_class.new
+        rescue NameError
+          bad_tester = true
+        end
+        
+        if bad_tester or !tester.respond_to? :test
+          raise ArgumentError, "'#{tester}' is not a valid tester. The parameter must be: 'responds_with_code', 'response_body_contains', or"+
+            " an Object or Class that responds to a 'test' method."
+        end
+      end
+      
+      tester.uri = @uri
+      
+      @failures = []
+      unless tester.test(*args)
+        notifiers.each {|n| n.notify(tester.failure)}
+        @failures << tester.failure
+      end
+      
+      # return self to allow for test chaining
+      return self
+    end
+  end
+end
+
+# this makes it possible to treat strings as Service objects
+class String
+  def test(tester, *args)
+    Opticon::Service.new(to_s).test(tester, *args)
+  end
+end

data/lib/opticon/tester.rb

@@ -0,0 +1,118 @@
+require 'opticon/http'
+require 'opticon/failure'
+
+module Opticon
+  module Tester
+    class Base
+      attr_accessor :uri
+      attr_reader :failure
+      
+      include Opticon::HTTP
+      
+      def test(*args)
+        begin
+          test_without_exception_handling(*args)
+        rescue SocketError, TimeoutError, Net::HTTPError, Errno::ECONNREFUSED
+          @failure = Opticon::Failure::ConnectionFailure.new(uri, args, nil)
+          @failure.exception = $!
+          false
+        end
+      end
+    end
+     
+    class ResponseCodeTester < Base
+      def test_without_exception_handling(condition)
+        case condition
+        when :ok
+          responds_with_code(200)
+        when :success
+          responds_with_success
+        when :failure, :error
+          responds_with_error
+        when :redirect
+          responds_with_redirect
+        when :client_error, :bad_request
+          responds_with_client_error
+        when :server_error
+          responds_with_server_error
+        when Integer, Array, Range
+          # TODO: if array, assert that each element is an integer (an HTTP response code)
+          responds_with_code(condition)
+        when String, Regexp
+          response_contains(condition)
+        else
+          raise ArgumentError, "'#{condition.inspect}' is not a valid argument for responds_with"
+        end
+      end
+      
+      private
+      def responds_with_code(codes)
+      
+        if codes.kind_of? Integer
+          result = codes == response.code.to_i
+        else
+          result = codes.include? response.code.to_i
+        end
+        
+        @failure = Opticon::Failure::ResponseCodeTestFailure.new(uri, codes, response) unless result
+        return result
+      end
+      
+      def responds_with_success
+        responds_with_code(200..206)
+      end
+      
+      def responds_with_redirect
+        responds_with_code(300..207)
+      end
+      
+      def responds_with_client_error
+        responds_with_code(400..417)
+      end
+      
+      def responds_with_server_error
+        responds_with_code(500..505)
+      end
+      
+      def responds_with_error
+        responds_with_client_error or responds_with_client_error
+      end
+    end
+    
+    class ContentTester < Base
+      def test_without_exception_handling(condition)
+        unless (200..206).include?(response.code.to_i)
+          @failure = Opticon::Failure::ContentTestFailure.new(uri, condition, response)
+          if (300..307).include?(response.code.to_i)
+            @failure.exception = RuntimeError.new("Request was redirected to #{response['location']}.")
+          else
+            @failure.exception = RuntimeError.new("Request returned code '#{response.message}'"+
+              " (#{response.code}) but response must be a 2xx HTTP status code.")
+          end
+          return false
+        end
+        
+        unless response.class.body_permitted?
+          @failure = Opticon::Failure::ContentTestFailure.new(uri, condition, response)
+          @failure.exception = RuntimeError.new("Response did not include a body (HTTP response: #{response.inspect})")
+          return false
+        end
+      
+        case condition
+        when Regexp
+          result = condition =~ response.body
+        when String
+          result = response.body.include? condition
+        end
+        
+        if result
+          @failure = nil
+        else
+          @failure = Opticon::Failure::ContentTestFailure.new(uri, condition, response)
+        end
+        
+        result
+      end
+    end
+  end
+end