outpost 0.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'net-ping', :require => false
+
+group :test do
+  gem 'thin'
+  gem 'rack'
+  gem 'sinatra'
+  gem 'ruby-debug19'
+end

data/Gemfile.lock

@@ -0,0 +1,39 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.2)
+    daemons (1.1.0)
+    eventmachine (0.12.10)
+    linecache19 (0.5.11)
+      ruby_core_source (>= 0.1.4)
+    net-ping (1.3.7)
+    rack (1.2.1)
+    ruby-debug-base19 (0.11.24)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.4)
+      archive-tar-minitar (>= 0.5.2)
+    sinatra (1.1.2)
+      rack (~> 1.1)
+      tilt (~> 1.2)
+    thin (1.2.7)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  net-ping
+  rack
+  ruby-debug19
+  sinatra
+  thin

data/README.markdown

@@ -0,0 +1,159 @@
+# Outpost
+
+Outpost is under development and is a project for the RMU: Ruby Mendicant
+University.
+
+## Features
+
+Outpost is a tool to monitor the state of your service (not server). What does it mean?
+
+It means:
+
+* it can monitor the state of a server, such as MySQL;
+* it can monitor some business rule to see if everything is running accordingly (such as cron jobs)
+* it can monitor several servers
+* it can monitor whatever you can code with Ruby
+
+It will connect to the related machines (it won't have any proxies/agents running on the servers to
+report data) and collect the data. The idea is to be completely uncoupled with the systems.
+It should report a status per declared system.
+
+The idea is to make a reliable framework for the Ruby developer to create his own monitoring rules.
+So, summing it all up, Nagios in Ruby, much cooler!
+
+## Installing
+
+    gem install outpost
+
+## Starting
+
+To create your Outposts, you must require 'outpost'. You also need to include
+'outpost/scouts' if you want to use the supplied scouts. Example:
+
+    require 'outpost'
+    require 'outpost/scouts'
+
+    class Bla < Outpost::DSL
+      using Outpost::Scouts::Http => "web page" do
+        options :host => 'localhost', :port => 3000
+        report :up, :response_code => 200
+      end
+    end
+
+    a = Bla.new
+    a.run
+    p a.messages # => ["Outpost::Scouts::Http: 'web page' is reporting up."]
+
+
+## How it works
+
+Consider the following example:
+
+    require 'outpost'
+    require 'outpost/scouts'
+
+    class HttpOutpostExample < Outpost::DSL
+      using Outpost::Scouts::Http => "web page" do
+        options :host => 'localhost', :port => 3000
+        report :up, :response_code => 200
+        report :down, :response_body => {:match => /Ops/}
+      end
+    end
+    outpost = HttpOutpostExample.new
+    outpost.run # => :down
+
+In this simple example, an Outpost was created to monitor a web server running
+on localhost at port 3000. Every time #run is called, the outpost will
+run associated rules (in this example, check if the HTTP response code is 200
+and report "up" if it does and also check if the response body matches /Ops/,
+reporting "down" in that case).
+
+## Outpost
+
+Outpost is the description of the system and provides a DSL to do it. 
+Check "How it works" section for an example, or check the [integration tests](https://github.com/vinibaggio/outpost/blob/master/test/integration/basic_dsl_test.rb)
+for more.
+
+## Scout
+
+Scout are pure Ruby classes that will test your server. For instance, check the
+Outpost::Scouts::Http example below:
+
+    module Outpost
+      module Scouts
+        class Http < Outpost::Scout
+          extend Outpost::Expectations::ResponseCode
+          extend Outpost::Expectations::ResponseBody
+
+          attr_reader :response_code, :response_body
+
+          def setup(options)
+            @host = options[:host]
+            @port = options[:port] || 80
+            @path = options[:path] || '/'
+          end
+
+          def execute
+            response = Net::HTTP.get_response(@host, @path, @port)
+            @response_code = response.code.to_i
+            @response_body = response.body
+          end
+        end
+      end
+    end
+
+It must implement the #setup and #execute methods. The magic lies in the #execute
+method, where you can implement any kind of logic to test whether your system is up
+or not. You may also include expectations in order to process the output of your system.
+For more information about expectations, check the section below.
+
+## Expectations
+
+Consider the following code snippet, taken from previous examples:
+
+    report :up, :response_code => 200
+    report :down, :response_body => {:match => /Ops/}
+
+In the example above, :response\_code and :response\_body are expectations, responsible
+to get Scout's output and evaluate it, in order to determine a status.
+
+They must be registered into each Scout that wish to support different types
+of expectations. You can supply a block or an object that respond to #call
+and return true if any of the rules match. It will receive an instance
+of the scout (so you can query current system state) as the first parameter 
+and the state defined in the #report method as the second.
+
+So you can easily create your own expectation. Let's recreate the :response\_code in
+ Outpost::Scouts::Http:
+
+    module Outpost
+      module Scouts
+        class Http < Outpost::Scout
+          expect(:response_code) { |scout,code| scout.response_code == code }
+
+          attr_reader :response_code
+
+          def setup(options)
+            @host = options[:host]
+            @port = options[:port] || 80
+            @path = options[:path] || '/'
+          end
+
+          def execute
+            response = Net::HTTP.get_response(@host, @path, @port)
+            @response_code = response.code.to_i
+          end
+        end
+      end
+    end
+
+You can also check the supplied expectations in the source of the project to have
+an idea on how to implement more complex rules.
+
+## TODO
+
+There's a lot to be done yet. For example, SSH support, :warning status, etc.
+
+## License
+
+MIT.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake/testtask'
+
+desc 'Default: run tests'
+task :default => :test
+
+desc 'Run tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/outpost.rb

@@ -0,0 +1,8 @@
+
+# Outpost definition
+require 'outpost/dsl'
+require 'outpost/report'
+
+# Scout definition
+require 'outpost/scout_config'
+require 'outpost/scout'

data/lib/outpost/dsl.rb

@@ -0,0 +1,54 @@
+module Outpost
+  class DSL
+    class << self
+      attr_reader :scouts
+
+      def using(scouts, &block)
+        @scouts ||= Hash.new { |h, k| h[k] = {} }
+
+        config = ScoutConfig.new
+        config.instance_eval(&block)
+
+        scouts.each do |scout, description|
+          @scouts[scout][:description] = description
+          @scouts[scout][:config]      = config
+        end
+      end
+    end
+
+    attr_reader :last_status, :reports
+
+    def run
+      @reports = self.class.scouts.map do |scout, options|
+        run_scout(scout, options)
+      end
+
+      statuses = @reports.map { |r| r.status }
+
+      @last_status = Report.summarize(statuses)
+    end
+
+    def up?
+      @last_status == :up
+    end
+
+    def down?
+      @last_status == :down
+    end
+
+    def messages
+      reports.map { |r| r.to_s }
+    end
+
+    def run_scout(scout, options)
+      scout_instance = scout.new(options[:description], options[:config])
+
+      params = {
+        :name        => scout.name,
+        :description => options[:description],
+        :status      => scout_instance.run
+      }
+      Report.new(params)
+    end
+  end
+end

data/lib/outpost/expectations.rb

@@ -0,0 +1,3 @@
+require 'outpost/expectations/response_code'
+require 'outpost/expectations/response_body'
+require 'outpost/expectations/response_time'

data/lib/outpost/expectations/response_body.rb

@@ -0,0 +1,22 @@
+module Outpost
+  module Expectations
+    module ResponseBody
+      RESPONSE_BODY_MAPPING = {
+        :match => "=~",
+        :not_match => "!~",
+        :equals => "==",
+        :differs => "!="
+      }.freeze
+
+      def self.extended(base)
+        base.expect :response_body, base.method(:evaluate_response_body)
+      end
+
+      def evaluate_response_body(scout, rules)
+        rules.all? do |rule,comparison|
+          scout.response_body.send(RESPONSE_BODY_MAPPING[rule], comparison)
+        end
+      end
+    end
+  end
+end

data/lib/outpost/expectations/response_code.rb

@@ -0,0 +1,13 @@
+module Outpost
+  module Expectations
+    module ResponseCode
+      def self.extended(base)
+        base.expect :response_code, base.method(:evaluate_response_code)
+      end
+
+      def evaluate_response_code(scout, response_code)
+        scout.response_code == response_code.to_i
+      end
+    end
+  end
+end

data/lib/outpost/expectations/response_time.rb

@@ -0,0 +1,20 @@
+module Outpost
+  module Expectations
+    module ResponseTime
+      RESPONSE_TIME_MAPPING = {
+        :less_than => "<",
+        :more_than => ">",
+      }.freeze
+
+      def self.extended(base)
+        base.expect :response_time, base.method(:evaluate_response_time)
+      end
+
+      def evaluate_response_time(scout, rules)
+        rules.all? do |rule,comparison|
+          scout.response_time.send(RESPONSE_TIME_MAPPING[rule], comparison)
+        end
+      end
+    end
+  end
+end

data/lib/outpost/report.rb

@@ -0,0 +1,28 @@
+module Outpost
+  class Report
+    # summarizes the list of statuses in a single status only.
+    # The logic is rather simple - it will return the lowest status
+    # present in the list.
+    #
+    # Examples:
+    #
+    # if passed [:up, :up, :up], will result on :up
+    # if passed [:up, :down, :up], will result on :down
+    def self.summarize(status_list)
+      return :down if status_list.empty? || status_list.include?(:down)
+      return :up
+    end
+
+    attr_reader :name, :description, :status
+
+    def initialize(params)
+      @name        = params[:name]
+      @description = params[:description]
+      @status      = params[:status]
+    end
+
+    def to_s
+      "#{name}: '#{description}' is reporting #{status}."
+    end
+  end
+end

data/lib/outpost/scout.rb

@@ -0,0 +1,56 @@
+module Outpost
+  class Scout
+    class << self
+
+      def expectations
+        @expectations ? @expectations.dup : []
+      end
+
+      def expect(expectation, callable=nil, &callable_block)
+        callable ||= callable_block
+
+        if callable.respond_to?(:call)
+          @expectations ||= {}
+          @expectations[expectation] = callable
+        else
+          raise ArgumentError, 'Object must respond to method #call to be a valid expectation.'
+        end
+      end
+    end
+
+    def initialize(description, config)
+      @description = description
+      @config      = config
+
+      setup(config.options)
+    end
+
+    def run
+      statuses = []
+      execute
+      @config.reports.each do |response_pair, status|
+        response_pair.each do |expectation, value|
+          if self.class.expectations[expectation].nil?
+            message = "expectation '#{expectation}' wasn't implemented by #{self.class.name}"
+            raise NotImplementedError, message
+          end
+
+          if self.class.expectations[expectation].call(self, value)
+            statuses << status
+          end
+        end
+      end
+
+      Report.summarize(statuses)
+    end
+
+    def setup(*args)
+      raise NotImplementedError, 'You must implement the setup method for Scout to work correctly.'
+    end
+
+    def execute(*args)
+      raise NotImplementedError, 'You must implement the execute method for Scout to work correctly.'
+    end
+
+  end
+end

data/lib/outpost/scout_config.rb

@@ -0,0 +1,31 @@
+module Outpost
+  class ScoutConfig
+    attr_reader :options, :reports
+
+    # Reads/writes any options. It will passed
+    # down to the scout.
+    def options(args=nil)
+      if args.nil?
+        @options
+      else
+        @options = args
+      end
+    end
+
+    # Reads reporting as:
+    #   report :up, :response_code => 200
+    #
+    # It reads much better in the DSL, but doesn't make
+    # much sense in terms of code, so it is changed to
+    # an inverted approach, so:
+    #   status = 200
+    #   params = {:response_code => 200}
+    #
+    #   gets stored as:
+    #    {:response_code => 200} = up
+    def report(status, params)
+      @reports ||= {}
+      @reports[params] = status
+    end
+  end
+end

data/lib/outpost/scouts.rb

@@ -0,0 +1,2 @@
+require 'outpost/scouts/http'
+require 'outpost/scouts/ping'

data/lib/outpost/scouts/http.rb

@@ -0,0 +1,28 @@
+require 'net/http'
+require 'outpost'
+
+require 'outpost/expectations'
+
+module Outpost
+  module Scouts
+    class Http < Outpost::Scout
+      extend Outpost::Expectations::ResponseCode
+      extend Outpost::Expectations::ResponseBody
+
+      attr_reader :response_code, :response_body
+
+      def setup(options)
+        @host = options[:host]
+        @port = options[:port] || 80
+        @path = options[:path] || '/'
+      end
+
+      def execute
+        # FIXME Apply Dependency Injection Principle here
+        response = Net::HTTP.get_response(@host, @path, @port)
+        @response_code = response.code.to_i
+        @response_body = response.body
+      end
+    end
+  end
+end

data/lib/outpost/scouts/ping.rb

@@ -0,0 +1,23 @@
+require 'net/ping/external'
+
+module Outpost
+  module Scouts
+    class Ping < Outpost::Scout
+      extend Outpost::Expectations::ResponseTime
+      attr_reader :response_time
+
+      def setup(options)
+        @host = options[:host]
+      end
+
+      def execute
+        # FIXME Apply Dependency Injection Principle here
+        pinger = Net::Ping::External.new
+        if pinger.ping(@host)
+          # Miliseconds
+          @response_time = pinger.duration * 100
+        end
+      end
+    end
+  end
+end

data/lib/outpost/version.rb

@@ -0,0 +1,3 @@
+module Outpost
+  VERSION = "0.1.0".freeze
+end

data/outpost.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "outpost/version"
+
+Gem::Specification.new do |s|
+  s.name        = "outpost"
+  s.version     = Outpost::VERSION.dup
+  s.description = "Simple service monitoring with a clean DSL for configuration."
+  s.summary     = "Simple service monitoring with a clean DSL for configuration."
+  s.author      = "Vinicius Baggio Fuentes"
+  s.email       = "vinibaggio@gmail.com"
+  s.homepage    = "http://www.github.com/vinibaggio/outpost"
+
+  s.rubyforge_project = "outpost"
+
+  s.files         = `git ls-files`.split("\n")                                          
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")                
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }   
+  s.require_paths = ["lib"]   
+
+  s.add_dependency("net-ping", "~> 1.3.7")
+end

data/test/integration/basic_dsl_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+require 'outpost/scouts/http'
+
+describe "basic DSL integration test" do
+  before(:each) do
+    @server = Server.new
+    @server.boot(TestApp)
+
+    while !@server.responsive?
+      sleep 0.1
+    end
+  end
+
+  class ExampleSuccess < Outpost::DSL
+    using Outpost::Scouts::Http => 'master http server' do
+      options :host => 'localhost', :port => 9595
+      report :up, :response_code => 200
+    end
+  end
+
+  class ExampleFailure < Outpost::DSL
+    using Outpost::Scouts::Http => 'master http server' do
+      options :host => 'localhost', :port => 9595, :path => '/fail'
+      report :up, :response_code => 200
+    end
+  end
+
+  class ExampleBodyFailure < Outpost::DSL
+    using Outpost::Scouts::Http => 'master http server' do
+      options :host => 'localhost', :port => 9595, :path => '/fail'
+      report :down, :response_body => {:equals => 'Omg fail'}
+    end
+  end
+
+  class ExampleBodySuccess < Outpost::DSL
+    using Outpost::Scouts::Http => 'master http server' do
+      options :host => 'localhost', :port => 9595, :path => '/'
+      report :up, :response_body => {:match => /Up/}
+    end
+  end
+
+  it "should report up when everything's ok" do
+    assert_equal :up, ExampleSuccess.new.run
+  end
+
+  it "should report failure when something's wrong" do
+    assert_equal :down, ExampleFailure.new.run
+  end
+
+  it "should report success when body is okay" do
+    assert_equal :up, ExampleBodySuccess.new.run
+  end
+
+  it "should report failure when body is wrong" do
+    assert_equal :down, ExampleBodyFailure.new.run
+  end
+end

data/test/integration/more_complex_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+require 'outpost/scouts'
+
+describe "using more complex DSL integration test" do
+  class ExamplePingAndHttp < Outpost::DSL
+    using Outpost::Scouts::Http => 'master http server' do
+      options :host => 'localhost', :port => 9595, :path => '/'
+      report :up, :response_body => {:match => /Up/}
+    end
+
+    using Outpost::Scouts::Ping => 'load balancer' do
+      options :host => 'localhost'
+      report :up, :response_time => {:less_than => 500}
+    end
+  end
+
+  class ExampleOneFailingOnePassing < Outpost::DSL
+    using Outpost::Scouts::Http => 'master http server' do
+      options :host => 'localhost', :port => 9595, :path => '/'
+      report :up, :response_body => {:match => /Up/}
+    end
+
+    using Outpost::Scouts::Ping => 'load balancer' do
+      options :host => 'localhost'
+      report :up, :response_time => {:less_than => 0}
+    end
+  end
+
+  class ExampleAllFailing < Outpost::DSL
+    using Outpost::Scouts::Http => 'master http server' do
+      options :host => 'localhost', :port => 9595, :path => '/fail'
+      report :up, :response_body => {:match => /Up/}
+    end
+
+    using Outpost::Scouts::Ping => 'load balancer' do
+      options :host => 'localhost'
+      report :up, :response_time => {:less_than => -1}
+    end
+  end
+
+  it "should report up when everything's ok" do
+    assert_equal :up, ExamplePingAndHttp.new.run
+  end
+
+  it "should report down when at least one scout reports down" do
+    assert_equal :down, ExampleOneFailingOnePassing.new.run
+  end
+
+  it "should report down when all are down" do
+    assert_equal :down, ExampleAllFailing.new.run
+  end
+
+  it "should build error message" do
+    outpost = ExampleAllFailing.new
+    outpost.run
+
+    assert_equal "Outpost::Scouts::Http: 'master http server' is reporting down.",
+      outpost.messages.first
+
+    assert_equal "Outpost::Scouts::Ping: 'load balancer' is reporting down.",
+      outpost.messages.last
+  end
+end

data/test/outpost/dsl_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+describe Outpost::DSL do
+  class ScoutMock
+    class << self
+      attr_accessor :status
+    end
+    def run; self.class.status; end
+  end
+
+  class ExampleOne < Outpost::DSL
+    using ScoutMock => 'master http server' do
+      options :host => 'localhost'
+      report :up, :response_code => 200
+    end
+  end
+
+  before(:each) do
+    @scouts = ExampleOne.scouts
+  end
+
+  it "should create correct scout description" do
+    assert_equal(ScoutMock, @scouts.keys.first)
+    assert_equal('master http server', @scouts[ScoutMock][:description])
+  end
+
+  it "should create correct scout config" do
+    config = @scouts[ScoutMock][:config]
+    assert_equal({:host => 'localhost'}, config.options)
+    assert_equal({{:response_code => 200} => :up}, config.reports)
+  end
+
+  describe "#up?" do
+    before(:each) do
+      @outpost = ExampleOne.new
+    end
+
+    it "should return true when last status is up" do
+      ScoutMock.status = :up
+      @outpost.run
+
+      assert @outpost.up?
+    end
+
+    it "should return false when last status isn't up" do
+      ScoutMock.status = :down
+      @outpost.run
+
+      refute @outpost.up?
+    end
+  end
+
+  describe "#down?" do
+    before(:each) do
+      @outpost = ExampleOne.new
+    end
+
+    it "should return true when last status is down" do
+      ScoutMock.status = :down
+      @outpost.run
+
+      assert @outpost.down?
+    end
+
+    it "should return false when last status isn't down" do
+      ScoutMock.status = :up
+      @outpost.run
+
+      refute @outpost.down?
+    end
+  end
+
+  describe "#messages" do
+    before(:each) do
+      @outpost = ExampleOne.new
+    end
+
+    it "should return true when last status is up" do
+      ScoutMock.status = :up
+      @outpost.run
+
+      assert_equal "ScoutMock: 'master http server' is reporting up.",
+        @outpost.messages.first
+    end
+  end
+end

data/test/outpost/expectations/response_body_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+describe Outpost::Expectations::ResponseBody do
+  class SubjectBody
+    class << self
+      attr_reader :expectation, :evaluation_method
+
+      def expect(expectation, evaluation_method)
+        @expectation       = expectation
+        @evaluation_method = evaluation_method
+      end
+
+    end
+    extend Outpost::Expectations::ResponseBody
+  end
+
+  describe ".evaluate_response_body with match" do
+    it "should return true when it matches" do
+      assert SubjectBody.evaluate_response_body(scout_mock, :match => /ll/)
+    end
+
+    it "should return false when it doesn't" do
+      refute SubjectBody.evaluate_response_body(scout_mock, :match => /omg/)
+    end
+  end
+
+  describe ".evaluate_response_body with not_match" do
+    it "should return true when it matches" do
+      assert SubjectBody.evaluate_response_body(scout_mock, :not_match => /omg/)
+    end
+
+    it "should return false when it doesn't" do
+      refute SubjectBody.evaluate_response_body(scout_mock, :not_match => /Hello/)
+    end
+  end
+
+  describe ".evaluate_response_body with equals" do
+    it "should return true when it matches" do
+      assert SubjectBody.evaluate_response_body(scout_mock, :equals => "Hello!")
+    end
+
+    it "should return false when it doesn't" do
+      refute SubjectBody.evaluate_response_body(scout_mock, :equals => "Hell")
+    end
+  end
+
+  describe ".evaluate_response_body with differs" do
+    it "should return true when it matches" do
+      assert SubjectBody.evaluate_response_body(scout_mock, :differs => "Hell")
+    end
+
+    it "should return false when it doesn't" do
+      refute SubjectBody.evaluate_response_body(scout_mock, :differs => "Hello!")
+    end
+  end
+
+  describe ".evaluate_response_body with multiple rules" do
+    it "should return true when all rules matches" do
+      rules = {:differs => 'omg', :match => /ll/}
+      assert SubjectBody.evaluate_response_body(scout_mock, rules)
+    end
+
+    it "should return false when there are no matches" do
+      rules = {:equals => 'omg', :not_match => /ll/}
+      refute SubjectBody.evaluate_response_body(scout_mock, rules)
+    end
+
+    it "should return false when at least one rule doesn't match" do
+      rules = {:equals => 'Hello!', :match => /Hell/, :differs => 'Hello!'}
+      refute SubjectBody.evaluate_response_body(scout_mock, rules)
+    end
+  end
+
+  it "should set expectation correctly" do
+    assert_equal :response_body, SubjectBody.expectation
+  end
+
+  it "should set evaluation method correctly" do
+    assert_equal SubjectBody.method(:evaluate_response_body), \
+      SubjectBody.evaluation_method
+  end
+
+  private
+  def scout_mock
+    @scout_mock ||= OpenStruct.new.tap do |scout_mock|
+      scout_mock.response_body = 'Hello!'
+    end
+  end
+end

data/test/outpost/expectations/response_code_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+require 'ostruct'
+
+describe Outpost::Expectations::ResponseCode do
+  class SubjectCode
+    class << self
+      attr_reader :expectation, :evaluation_method
+
+      def expect(expectation, evaluation_method)
+        @expectation       = expectation
+        @evaluation_method = evaluation_method
+      end
+
+    end
+    extend Outpost::Expectations::ResponseCode
+  end
+
+  it "should return true when response codes match" do
+    assert SubjectCode.evaluate_response_code(scout_mock, 200)
+  end
+
+  it "should return false when response codes doesn't match" do
+    refute SubjectCode.evaluate_response_code(scout_mock, 404)
+  end
+
+  it "should convert types accordinly" do
+    assert SubjectCode.evaluate_response_code(scout_mock, "200")
+  end
+
+  it "should set expectation correctly" do
+    assert_equal :response_code, SubjectCode.expectation
+  end
+
+  it "should set evaluation method correctly" do
+    assert_equal SubjectCode.method(:evaluate_response_code),
+      SubjectCode.evaluation_method
+  end
+
+  private
+  def scout_mock
+    @scout_mock ||= OpenStruct.new.tap do |scout_mock|
+      scout_mock.response_code = 200
+    end
+  end
+end

data/test/outpost/expectations/response_time_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+describe Outpost::Expectations::ResponseTime do
+  class SubjectTime
+    class << self
+      attr_reader :expectation, :evaluation_method
+
+      def expect(expectation, evaluation_method)
+        @expectation       = expectation
+        @evaluation_method = evaluation_method
+      end
+
+    end
+    extend Outpost::Expectations::ResponseTime
+  end
+
+  describe ".evaluate_response_time with less_than" do
+    it "should return true when it matches" do
+      assert SubjectTime.evaluate_response_time(scout_mock, :less_than => 5000)
+    end
+
+    it "should return false when it doesn't" do
+      refute SubjectTime.evaluate_response_time(scout_mock, :less_than => 1)
+    end
+  end
+
+  describe ".evaluate_response_time with more_than" do
+    it "should return true when it matches" do
+      assert SubjectTime.evaluate_response_time(scout_mock, :more_than => 1)
+    end
+
+    it "should return false when it doesn't" do
+      refute SubjectTime.evaluate_response_time(scout_mock, :more_than => 5000)
+    end
+  end
+
+  describe ".evaluate_response_time with multiple rules" do
+    it "should return true when all rules matches" do
+      rules = {:more_than => 200, :less_than => 5000}
+      assert SubjectTime.evaluate_response_time(scout_mock, rules)
+    end
+
+    it "should return false when there are no matches" do
+      rules = {:more_than => 700, :less_than => 200}
+      refute SubjectTime.evaluate_response_time(scout_mock, rules)
+    end
+
+    it "should return false when at least one rule doesn't match" do
+      rules = {:more_than => 100, :less_than => 200}
+      refute SubjectTime.evaluate_response_time(scout_mock, rules)
+    end
+  end
+
+  it "should set expectation correctly" do
+    assert_equal :response_time, SubjectTime.expectation
+  end
+
+  it "should set evaluation method correctly" do
+    assert_equal SubjectTime.method(:evaluate_response_time),
+      SubjectTime.evaluation_method
+  end
+
+  private
+  def scout_mock
+    @scout_mock ||= OpenStruct.new.tap do |scout_mock|
+      scout_mock.response_time = 300
+    end
+  end
+end
+

data/test/outpost/report_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+describe Outpost::Report do
+  it "should report up when all are up" do
+    assert_equal :up, Outpost::Report.summarize([:up, :up, :up, :up])
+  end
+
+  it "should report down when mixed statuses" do
+    assert_equal :down, Outpost::Report.summarize([:up, :down, :up, :up])
+  end
+
+  it "should report down when all are down" do
+    assert_equal :down, Outpost::Report.summarize([:down, :down, :down])
+  end
+
+  it "should report down when there are no statuses" do
+    assert_equal :down, Outpost::Report.summarize([])
+  end
+end

data/test/outpost/scout_config_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+describe Outpost::ScoutConfig do
+  before(:each) do
+    @config = Outpost::ScoutConfig.new
+  end
+
+  it "should assign options accordingly" do
+    @config.options :host => 'localhost'
+
+    assert_equal({:host => 'localhost'}, @config.options)
+  end
+
+  it "should assign reports accordingly" do
+    @config.report :up, :response_code => 200
+
+    assert_equal({{:response_code => 200} => :up}, @config.reports)
+  end
+
+  it "should assign multiple reports" do
+    @config.report :up, :response_code => 200
+    @config.report :down, :response_code => 404
+
+    assert_equal({
+        {:response_code => 200} => :up,
+        {:response_code => 404} => :down,
+      }, @config.reports)
+  end
+end

data/test/outpost/scout_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+require 'ostruct'
+
+describe Outpost::Scout do
+  NoisyError = Class.new(StandardError)
+
+  class ScoutExample < Outpost::Scout
+    attr_accessor :response
+    expect :response, lambda {|scout, status| scout.response == status }
+
+    def setup(*args); end
+    def execute(*args); end
+  end
+
+  it "should report up when status match" do
+    scout = ScoutExample.new("a scout", config_mock)
+    scout.response = true
+    assert_equal :up, scout.run
+  end
+
+  it "should report up when status match" do
+    scout = ScoutExample.new("a scout", config_mock)
+    scout.response = false
+    assert_equal :down, scout.run
+  end
+
+  it "should not register an invalid expectation" do
+    assert_raises ArgumentError do
+      add_expectation(:invalid_expectation, nil)
+    end
+  end
+
+  it "should register a expectation using a lambda" do
+    add_expectation(:valid_expectation, lambda{|b| b})
+
+    refute_nil ScoutExample.expectations[:valid_expectation]
+  end
+
+  it "should register a expectation using pure blocks for flexibility" do
+    ScoutExample.expect(:valid_expectation) { |b| b }
+
+    refute_nil ScoutExample.expectations[:valid_expectation]
+  end
+
+  it "should not be able to have its expectations modified" do
+    ScoutExample.expectations[:another_expectation] = {}
+    assert_nil ScoutExample.expectations[:another_expectation]
+  end
+
+  it "should not call expectation when there are no rules for that" do
+    add_expectation(:noisy, proc {|s,r| raise NoisyError})
+    assert_nothing_raised do
+      scout = ScoutExample.new("a scout", config_mock)
+      scout.run
+    end
+  end
+
+  it "should call expectation when there are rules for that" do
+    add_expectation(:noisy, proc {|s,r| raise NoisyError})
+    config = config_mock
+    config.reports[{:noisy => nil}] = :down
+
+    assert_raises NoisyError do
+      scout = ScoutExample.new("a scout", config)
+      scout.run
+    end
+  end
+
+  it "should complain when an unregistered expectation is called" do
+    config = config_mock
+    config.reports[{:unregistered => nil}] = :up
+
+    assert_raises NotImplementedError do
+      scout = ScoutExample.new("a scout", config)
+      scout.run
+    end
+  end
+
+  private
+  def config_mock
+    OpenStruct.new.tap do |config|
+      config.reports = {}
+      config.reports[{:response => true}] = :up
+      config.reports[{:response => false}] = :down
+    end
+  end
+
+  def add_expectation(expectation, callable)
+    ScoutExample.expect expectation, callable
+  end
+end

data/test/support/server.rb

@@ -0,0 +1,24 @@
+require 'rack/handler/thin'
+require 'net/http'
+
+class Server
+  # Got it from Capybara, but simplified it a bit.
+  # lib/capybara/server.rb
+  def responsive?
+    res = Net::HTTP.start('localhost', 9595) { |http| http.get('/') }
+
+    res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
+  rescue Errno::ECONNREFUSED, Errno::EBADF
+    return false
+  end
+
+  def boot(app)
+    if not responsive?
+      Thread.new do
+        Thin::Logging.silent = true
+        Rack::Handler::Thin.run(app, :Port => 9595)
+      end
+    end
+  end
+
+end

data/test/support/test_app.rb

@@ -0,0 +1,11 @@
+require 'sinatra/base'
+
+class TestApp < Sinatra::Base
+  get '/' do
+    [200, 'Up and running!']
+  end
+
+  get '/fail' do
+    [500, 'Omg fail']
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler.setup(:default, :test)
+
+require 'ruby-debug'
+require 'minitest/spec'
+require 'minitest/autorun'
+
+# Integration test helpers
+require 'support/test_app'
+require 'support/server'
+
+require 'outpost'
+require 'outpost/expectations'
+
+# Inspired by assert_raises from minitest
+def assert_nothing_raised(&block)
+  block.call
+rescue Exception => e
+  flunk "No exception expected, but #{mu_pp(e.class)} was raised."
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: outpost
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Vinicius Baggio Fuentes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-01 00:00:00 -02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ping
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 7
+        version: 1.3.7
+  type: :runtime
+  version_requirements: *id001
+description: Simple service monitoring with a clean DSL for configuration.
+email: vinibaggio@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Gemfile.lock
+- README.markdown
+- Rakefile
+- lib/outpost.rb
+- lib/outpost/dsl.rb
+- lib/outpost/expectations.rb
+- lib/outpost/expectations/response_body.rb
+- lib/outpost/expectations/response_code.rb
+- lib/outpost/expectations/response_time.rb
+- lib/outpost/report.rb
+- lib/outpost/scout.rb
+- lib/outpost/scout_config.rb
+- lib/outpost/scouts.rb
+- lib/outpost/scouts/http.rb
+- lib/outpost/scouts/ping.rb
+- lib/outpost/version.rb
+- outpost.gemspec
+- test/integration/basic_dsl_test.rb
+- test/integration/more_complex_test.rb
+- test/outpost/dsl_test.rb
+- test/outpost/expectations/response_body_test.rb
+- test/outpost/expectations/response_code_test.rb
+- test/outpost/expectations/response_time_test.rb
+- test/outpost/report_test.rb
+- test/outpost/scout_config_test.rb
+- test/outpost/scout_test.rb
+- test/support/server.rb
+- test/support/test_app.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://www.github.com/vinibaggio/outpost
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: outpost
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple service monitoring with a clean DSL for configuration.
+test_files: 
+- test/integration/basic_dsl_test.rb
+- test/integration/more_complex_test.rb
+- test/outpost/dsl_test.rb
+- test/outpost/expectations/response_body_test.rb
+- test/outpost/expectations/response_code_test.rb
+- test/outpost/expectations/response_time_test.rb
+- test/outpost/report_test.rb
+- test/outpost/scout_config_test.rb
+- test/outpost/scout_test.rb
+- test/support/server.rb
+- test/support/test_app.rb
+- test/test_helper.rb