rubicante 0.0.1

data/lib/rubicante/host.rb

@@ -0,0 +1,140 @@
+require 'rubicante/website'
+require 'rubicante/host_error'
+
+require 'logging'
+require 'ping'
+require 'socket'
+
+module Rubicante
+  class Host
+    attr_reader :name
+    attr_accessor :ports, :services, :types, :websites
+
+    def initialize(name)
+      @name     = name
+      @ports    = []
+      @services = []
+      @types    = []
+      @websites = []
+
+      @log = Logging::Logger[self]
+
+      # Prepare Website logger
+      @appender = Logging::Appender['rubicante']
+      Logging::Logger['Rubicante::Website'].add_appenders(Logging::Appender['rubicante']) if not @appender.nil?
+      Logging::Logger['Rubicante::Website'].level = @log.level
+    end
+
+    def ping
+      @log.debug "Performing TCP echo ping on host '#{@name}'"
+      Ping.pingecho @name
+    end
+
+    def port(port_number)
+      @ports << port_number
+      self
+    end
+
+    def service(service_name)
+      @services << service_name
+      self
+    end
+
+    def type(type_name)
+      @types << type_name
+      self
+    end
+
+    def website(website_url)
+      @websites << Website.new(website_url)
+      self
+    end
+
+    # Check if the specified port is active by connecting to it
+    def check_port(port)
+      port_output = "#{@name}:#{port}"
+
+      @log.debug "Checking port #{port_output}..."
+
+      begin
+        test = TCPSocket.open(@name, port)
+        @log.debug "Port #{port_output} looks good"
+        return true # if we get here, the socket opened
+      rescue
+        @log.debug "Port #{port_output} raised an exception when opening"
+        return false  # if we get here, there are problems with the port
+      end
+    end
+
+    # Iterates through all the ports in the Host and runs check_port(port)
+    # against them.
+    #
+    # == Yields: port, is_alive
+    #
+    # Each registered port is yielded along with the boolean result from
+    # check_port(port).
+    #
+    # == Example:
+    #
+    #   host = Rubicante::Host.new("test-host")
+    #   host.port(80)
+    #   host.port(443)
+    #
+    #   host.check_ports do |port, response|
+    #     puts "Port #{port} is UP" if response
+    #     puts "Port #{port} is DOWN" if not response
+    #   end
+    def check_ports
+      @ports.each do |port|
+        yield port, check_port(port)
+      end
+    end
+
+    # Iterates through all the websites in the Host and runs
+    # wrong? against them looking for problems.  If a problem is
+    # found, a Hash of the URL and the HTTP Status code is yielded.
+    #
+    # == Yields: a Hash
+    #
+    #   {
+    #     :url    => String,  # the URL of the current website in the block
+    #     :code   => String   # the HTTP Status code of the check (i.e., 404, 500, etc.)
+    #   }
+    #
+    # == Example
+    #
+    #   host = Rubicante::Host.new("test-host")
+    #   host.website('www.exmaple.com')
+    #   host.website('www.rubicante.com')
+    #   host.website('www.openbsd.org')
+    #
+    #   host.check_websites do |result|
+    #     puts "Website #{result[:url]} failed with code #{result[:code]}!"
+    #   end
+    def check_websites
+      @log.debug "Checking websites registered to host '#{@name}'"
+      @websites.each do |website|
+        yield website.wrong?
+      end
+    end
+
+    def wrong?
+      @log.debug "Determing what is wrong with host '#{@name}'"
+      result = HostError.new(@name)
+      result.ping = self.ping
+
+      # If the host is alive, continue testing
+      if result.ping
+        check_ports do |port, response|
+          result.bad_ports << port if not response
+        end
+
+        check_websites do |website_error|
+          result.add(website_error)
+        end
+      end
+
+      return result
+    end
+  end
+end

data/lib/rubicante/host_error.rb

@@ -0,0 +1,21 @@
+require 'rubicante/website_error'
+
+module Rubicante
+  class HostError
+    attr_reader :hostname, :website_errors
+    attr_accessor :bad_ports, :ping
+
+    def initialize(hostname)
+      @hostname = hostname
+      @ping = false
+      @bad_ports      = []
+      @website_errors = []
+    end
+
+    def add(error)
+      if error.kind_of? WebsiteError
+        @website_errors << error
+      end
+    end
+  end
+end

data/lib/rubicante/host_group.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+require 'rubicante/host'
+
+module Rubicante
+  class HostGroup
+    include Singleton
+
+    attr_reader :hosts
+
+    def initialize
+      @hosts = {}
+    end
+
+    def [](hostname)
+      @hosts[hostname] ||= Host.new(hostname)
+    end
+  end
+end

data/lib/rubicante/type.rb

@@ -0,0 +1,20 @@
+module Rubicante
+  class Type
+    attr_reader :name
+    attr_accessor :ports, :services
+
+    def initialize(name)
+      @name     = name
+      @ports    = []
+      @services = []
+    end
+
+    def port(new_port)
+      @ports << new_port
+    end
+
+    def service(new_service)
+      @services << new_service
+    end
+  end
+end

data/lib/rubicante/type_group.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+require 'rubicante/type'
+
+module Rubicante
+  class TypeGroup
+    include Singleton
+
+    attr_accessor :types
+
+    def initialize
+      @types  = {}
+    end
+
+    def [](type_name)
+      @types[type_name] ||= Type.new(type_name)
+    end
+  end
+end

data/lib/rubicante/website.rb

@@ -0,0 +1,54 @@
+require 'rubicante/website_error'
+
+require 'logging'
+require 'net/http'
+
+module Rubicante
+  class Website
+    attr_reader :url
+    
+    def initialize(url)
+      @url = url
+
+      @log = Logging::Logger[self]
+    end
+
+    # Determines whether or not the site OK based on the HTTP Status code
+    #
+    # == DETERMINING IF A SITE IS OK
+    #
+    # When performing an HTTP GET on the root, if a 2xx (HTTP OK) or
+    # 3xx (HTTP Redirect) response is received, the method considers the
+    # site to be workinging nominally and returns *true*
+    #
+    # However, if a 4xx (HTTP Client Error) or 5xx (HTTP Server Error)
+    # response is received, the method considers the site to be working
+    # abnormally and returns *false*
+    def is_ok?
+      result = false
+
+      result = true if response_code.match(/^(2|3)/)
+
+      return result
+    end
+
+    # Performs and HTTP GET on the URL's root ('/') and returns the
+    # HTTP Status code
+    def response_code
+      @log.debug "Retreiving HTTP Code for website '#{@url}'"
+      result = Net::HTTP.get_response(@url, '/').code
+      @log.debug "Received HTTP Code #{result} for website '#{@url}'"
+
+      return result
+    end
+
+    # Checks to see if the site is OK.  If it is not, it returns
+    # a Rubicante::WebsiteError
+    def wrong?
+      @log.debug "Checking website '#{@url}' for problems"
+      if not self.is_ok?
+        WebsiteError.new(@url, self.response_code)
+      end
+    end
+  end
+end

data/lib/rubicante/website_error.rb

@@ -0,0 +1,10 @@
+module Rubicante
+  class WebsiteError
+    attr_reader :code, :url
+
+    def initialize(url, code)
+      @url  = url
+      @code = code
+    end
+  end
+end

data/spec/environment_spec.rb

@@ -0,0 +1,84 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/environment" 
+
+describe "A Rubicante environment" do
+  before :all do
+    Net::HTTP.stub!(:get_response).and_return(Net::HTTPServerError.new('1', '500', 'Internal Server Error'))
+  end
+
+  before :each do
+    @env = Rubicante::Environment.new
+  end
+
+  it "should exist" do
+    @env.should_not be_nil
+    @env.should be_an_instance_of(Rubicante::Environment)
+  end
+
+  it "should have a HostGroup" do
+    @env.host.should be_an_instance_of(Rubicante::HostGroup)
+  end
+
+  it "should have an empty HostGroup by default" do
+    @env.host.hosts.should == {}
+  end
+
+  it "should have a wrong? method" do
+    @env.respond_to?('wrong?').should == true
+  end
+
+  it "should return an array of HostErrors" do
+    @env.wrong? do |result|
+      result.should be_an_instance_of(Array)
+      result[0].should be_an_instance_of(Rubicante::HostError)
+    end
+  end
+
+  it "should have an eval_host method" do
+    @env.respond_to?('eval_host').should == true
+  end
+
+  it "should handle 'Host webservice provides website ...'" do
+    hostname = 'webservice'
+    url = 'www.rubicante-example.com'
+    cmd = "Host #{hostname} provides website #{url}"
+    @env.eval_host(cmd)
+    @env.host[hostname].websites[0].url.should == url
+  end
+
+  it "should handle specifying multiple websites" do
+    hostname = 'www2'
+    url0 = 'test1'
+    url1 = 'test2'
+    cmd = "Host #{hostname} provides website #{url0}, provides website #{url1}"
+    @env.eval_host(cmd)
+    @env.host[hostname].websites[0].url.should == url0
+    @env.host[hostname].websites[1].url.should == url1
+  end
+
+  it "should have an eval_command method" do
+    @env.respond_to?('eval_command').should == true
+  end
+
+  it "should raise a NotImplementedError for unknown commands" do
+    lambda { @env.eval_command('whumpus frumpus') }.should raise_error(NotImplementedError)
+  end
+
+  it "should handle 'host' commands" do
+    lambda { @env.eval_command('host frank') }.should_not raise_error(NotImplementedError)
+  end
+
+  it "should have an eval_what method" do
+    @env.respond_to?('eval_what').should == true
+  end
+
+  it "should handle 'what' commands" do
+    lambda { @env.eval_command('What is wrong') }.should_not raise_error(NotImplementedError)
+  end
+
+  after :each do
+    # Clean up the HostGroup instance's hash so that other specs will
+    # run properly
+    @env.host.hosts.clear
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,3 @@
+require "spec" 
+
+LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)), *%w[.. lib rubicante])

data/spec/host_error_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/host_error" 
+
+describe "An error with a host" do
+  before :all do
+    @url = "http://www.rubicante-example.com/"
+    @code = "500"
+    @website_error = Rubicante::WebsiteError.new(@url, @code)
+  end
+
+  before :each do
+    @host_error = Rubicante::HostError.new("test-host")
+  end
+
+  it "should exist" do
+    @host_error.should_not be_nil
+    @host_error.should be_an_instance_of(Rubicante::HostError)
+  end
+
+  it "should require an argument at initialization" do
+    lambda { Rubicante::HostError.new }.should raise_error(ArgumentError)
+  end
+
+  it "should now allow changing of hostname after initialization" do
+    lambda { @host_error.hostname = "new-host-name" }.should raise_error(NoMethodError)
+  end
+
+  it "should have an empty array of website errors" do
+    @host_error.website_errors.should == []
+  end
+
+  it "should allow adding of new website errors with add" do
+    @host_error.add(@website_error)
+    @host_error.website_errors.include?(@website_error).should == true
+  end
+
+  it "should have an ping value" do
+    @host_error.respond_to?('ping').should == true
+  end
+
+  it "ping should be false by default" do
+    @host_error.ping.should == false
+  end
+
+  it "should allow changin the ping value" do
+    @new_ping = true
+    @host_error.ping.should_not == @new_ping
+    @host_error.ping = @new_ping
+    @host_error.ping.should == @new_ping
+  end
+
+  it "should have an empty array of bad_ports by default" do
+    @host_error.bad_ports.should == []
+  end
+
+  it "should allow appending to bad_ports" do
+    @new_bad_port = 80
+    @host_error.bad_ports << 80
+    @host_error.bad_ports.include?(@new_bad_port).should == true
+  end
+end

data/spec/host_group_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/host_group" 
+
+describe "A group of hosts" do
+  before :each do
+    @host_group = Rubicante::HostGroup.instance
+  end
+
+  it "should exist" do
+    @host_group.should_not be_nil
+    @host_group.should be_an_instance_of(Rubicante::HostGroup)
+  end
+
+  it "should have an empty hash of hosts by default" do
+    @host_group.hosts.should == {}
+  end
+
+  it "should create a new host in hosts if it doesn't exist" do
+    hostname = "new-host"
+    @host_group[hostname].name.should == hostname
+  end
+
+  it "should allow for modifying previously defined hosts" do
+    hostname    = "new-host"
+    new_port    = 80
+    new_service = "new-service"
+
+    @host_group[hostname].port(new_port).service(new_service)
+
+    @host_group[hostname].ports.include?(new_port).should == true
+    @host_group[hostname].services.include?(new_service).should == true
+  end
+end