inari 0.1.0

data/InstalledFiles

@@ -0,0 +1 @@
+/usr/local/lib/ruby/site_ruby/1.8/inari.rb

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006-2007 Alex Young, Helicoid Limited
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,64 @@
+= +inari+
+
++inari+ is a simple network monitoring tool, intended for use with web services.  It uses a user-friendly configuration file in a similar manner to Rake and Capistrano.
+
++inari+ is written in Ruby, can be extended through Ruby modules, and currently requires little external dependencies.
+
+== Usage
+
++inari+ can be Run with:
+
++inari+.rb start/stop configuration_file
+
+The configuration file is optional.  If it isn't supplied, $prefix/etc/inari.conf is assumed (this is likely to be /usr/local).
+
+== Configuration
+
++inari+'s configuration files are created using a simple domain-specific language, allowing you to clearly express how you want your services monitored.
+
+=== Server definition
+
+A set of servers must be defined.  Each server can have several hosts.  This is intended to make monitoring a web server cluster or set of similar services simple.
+
+Servers can be defined as follows:
+
+server :local, 'localhost'
+server :blogs, 'blog.helicoid.net', 'mmm.helicoid.net'
+
+=== Task definitions
+
++inari+ currently runs tasks as threaded processes, allowing them to run independently regardless of issues such as timeouts and software errors.
+
+Tasks are a set of commands that allow you to define:
+
+* What you want monitored
+* How you want it monitored
+* What you want to happen on an event
+
+You can also supply a description of the task to explain it more clearly.
+
+For example, this task fetches a web page every 60 seconds and sends an email whenever the page is unreachable:
+
+desc "Defaults example: email"
+task :example, :servers => [:local] do
+  get_web_page '/'
+  frequency '60 seconds'
+  email_on_events
+end
+
+The required servers have been specified using the task header definition:
+
+task :example, :servers => [:local] do
+
+Then a set of commands have been provided.  get_web_page will fetch the required page.  email_on_events is a standard command built into +inari+ that will send an email whenever the state of the service changes.
+
+=== Additional events
+
+If you don't want your inbox filling up with emails, you can use log_on_events.  This writes event notifications to a log file, which you can monitor with tail -f in the command line.
+
+=== Configuration settings
+
+To configure where you want the emails to be sent, add this line to the top of the file:
+
+config :email_to, 'alex@example.com'
+

data/Rakefile

@@ -0,0 +1,62 @@
+$:.unshift 'lib' if File.directory? 'lib'
+
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'inari/version'
+
+desc 'Run the functional and unit tests.'
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+desc 'Generate rdoc documentation'
+Rake::RDocTask.new('rdoc') do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'inari'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/*.rb')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test
+
+Spec = Gem::Specification.new do |s|
+  s.name = 'inari'
+  s.version = Inari::INARI_VERSION
+  s.date = Inari::INARI_RELEASE_DATE
+  s.summary = 'Inari is a ruby system monitoring program.'
+  s.email = 'alex@helicoid.net'
+  s.homepage = Inari::UPSTREAM_URL
+  s.rubyforge_project = 'inari'
+  s.autorequire = 'inari'
+  s.bindir = 'bin'
+  s.executables = ['inari']
+  s.has_rdoc = true
+  s.files = FileList['lib/**/*.rb', 'bin/*', '[A-Z]*', 'test/**/*'].to_a
+  s.test_files = Dir['test/test_*.rb']
+  s.requirements = ['logger']  
+  s.post_install_message = <<EOF
+
+Welcome to Inari
+================
+
+Inari is a small and extenable system monitor, intended for us with
+web applications.  To start using it, tailor #{Config::CONFIG['prefix'] + '/etc/inari.conf'}
+to your requirements.
+
+Take a look at README for help on writing configuration files.
+
+http://inari.rubyforge.org
+
+EOF
+
+end
+
+task :gem => [:test]
+Rake::GemPackageTask.new(Spec) do |p|
+  p.need_tar = true
+end
+

data/THANKS

@@ -0,0 +1,5 @@
+Gabriel Gironda
+    http://gabriel.gironda.org/
+
+Minero Aoki
+    http://i.loveruby.net/en/projects/setup/

data/bin/inari

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby
+require 'inari'
+
+# Run Inari
+Inari.go

data/lib/inari/commands/defaults.rb

@@ -0,0 +1,33 @@
+module Defaults
+  def sig
+    return <<SIGNATURE
+
+This message was reported by your system monitoring software.
+
+--
+#{Inari::APP_NAME}
+
+SIGNATURE
+  end
+  
+  def log_on_events
+    on_down do
+      Inari::logger.error("#{current_host} is down.")
+    end
+  
+    on_up do
+      Inari::logger.info("#{current_host} came back after #{down_for} seconds")
+    end
+  end
+  
+  def email_on_events
+    on_down do
+      email(:subject => "#{current_host} is down", :body => "#{current_host} is down." + sig)
+    end
+  
+    on_up do
+      email(:subject => "#{current_host} is up (down for #{down_for} seconds)",
+            :body => "#{current_host} is up (down for #{down_for} seconds)" + sig)
+    end
+  end
+end

data/lib/inari/commands/http.rb

@@ -0,0 +1,42 @@
+require 'net/http'
+
+module HTTP
+  # HTTP commands
+  def page_size(response = nil)
+    response = @last_response if response.nil?
+    response.body.size rescue 0
+  end
+
+  def page_content; @last_response.body; end 
+
+  def get_web_page(page)
+    Timeout::timeout(@timeout) do
+      response = Net::HTTP.get_response(@host, page, @port || 80)
+      add_response(page, response)
+  
+      # Return true when a 200 is returned, in case people use get_web_page as a condition
+      response.code == '200'
+    end
+  rescue
+    add_response(page, Response.new(:code => $!), true)
+    false
+  end
+
+  def unexpected_page_change
+    @first_response = @last_response if @first_response.nil? and @last_response
+
+    # Fetch a fresh copy of the page and retain the last one
+    page_size(@first_response) == page_size
+  end
+
+  #def when_http_status_is(status, invert = false, &block)
+  #  response = Net::HTTP.get_response(@host, @path)
+  #  if status.to_i == response.code.to_i and not invert
+  #    instance_eval(&block) if block
+  #  end
+  #end
+  #
+  #def when_http_status_is_not(status, &block)
+  #  when_http_status_is(status, true, &block)
+  #end
+end

data/lib/inari/commands/reporting.rb

@@ -0,0 +1,17 @@
+module Reporting
+  def email(options={})
+    from = "#{Etc.getlogin}@#{Socket.gethostname}"
+    to = Inari::configuration.options[:email_to]
+    message =<<MESSAGE
+From: #{from}
+To: #{to}
+Subject: #{options[:subject]}
+
+#{options[:body]}
+MESSAGE
+
+    Net::SMTP.start(Inari::configuration.options[:smtp_host]) do |smtp|
+      smtp.send_message message, from, to
+    end
+  end
+end

data/lib/inari/commands/smtp.rb

@@ -0,0 +1,16 @@
+require 'net/smtp'
+
+module SMTP
+  # SMTP commands
+  def get_smtp_helo
+    response = Response.new
+    begin
+      Net::SMTP.start(@host, port=@port, helo=@localhost, user=nil, secret=nil, authtype=nil)
+      add_response('helo', Response.new(:code => 'Connection accepted'))
+      true
+    rescue
+      add_response('helo', Response.new(:code => $!), true)
+      false
+    end
+  end
+end

data/lib/inari/commands/snmp.rb

@@ -0,0 +1,30 @@
+require 'snmp'
+
+module SNMP
+  # SNMP commands
+  def get_snmp_out(interface)
+    snmp_walk().each do |snmp_data|
+      return snmp_data[2].to_i if (snmp_data[1] == interface.to_s)
+    end
+    return 0
+  end
+  
+  def get_snmp_in(interface)
+    snmp_walk().each do |snmp_data|
+      return snmp_data[3].to_i if (snmp_data[1] == interface.to_s)
+    end
+    return 0
+  end
+
+  def snmp_walk()
+    columns, values, snmp_data = ['ifIndex', 'ifDescr', 'ifInOctets', 'ifOutOctets'], [], []
+    SNMP::Manager.open(:Host => 'mon') do |manager|
+      manager.walk(columns) do |row|
+        row.each { |vb| values << vb.value }
+      end
+
+      values.each_slice(4) { |slice| snmp_data << slice }
+    end
+    snmp_data
+  end
+end

data/lib/inari/commands/tcp_simple.rb

@@ -0,0 +1,24 @@
+# The simplest commands in the toolset: These check a por is available
+module TCPSimple
+  def up?
+    state = false
+    name = @host + ' TCP check'
+    
+    begin
+      Timeout::timeout(@timeout) do
+        t = TCPSocket.new(@host, @port)
+        state = true
+        add_response(name, Response.new(:code => 'Up'))
+      end
+    rescue
+      Inari::logger.error "TCP error: #{$!} for host: #{@host}, port: #{@port}"
+      add_response(name, Response.new(:code => $!), true)
+    ensure
+      t.close if defined? t
+    end
+    
+    return state
+  end
+  
+  def down? ; !up? ; end
+end

data/lib/inari/commands/test.rb

@@ -0,0 +1,9 @@
+module TestCommands
+  def run_test(probability)
+    if rand(100) > probability
+      add_response('Test', Response.new(:code => '200'))
+    else
+      add_response('Test', Response.new(:code => '404'), true)
+    end
+  end
+end

data/lib/inari/commands.rb

@@ -0,0 +1,158 @@
+# The response object
+require 'inari/response'
+
+# The command drivers
+require 'inari/commands/http'
+require 'inari/commands/snmp'
+require 'inari/commands/smtp'
+require 'inari/commands/reporting'
+require 'inari/commands/tcp_simple'
+require 'inari/commands/defaults'
+require 'inari/commands/test'
+
+module Inari
+  # This is the configuration API.  These methods can be used from configuration files.
+  #
+  # +Commands+ is currently a singleton because mixins are used to extend the functionality
+  # with different types of protocols.  I thought this would be more efficient than instantiating
+  # a +Commands+ object for each task.  A host is set, then methods can be called.  Results for
+  # the currently set host will be stored internally as hashes or arrays.
+  #
+  # This is a good area for improvement, perhaps by adding a simple plugin system:
+  #
+  #   http://eigenclass.org/hiki.rb?cmd=view&p=ruby+plugins&key=plugin
+  #
+  class Commands
+    include Singleton
+    
+    # The taskmanager created for this command instance.
+    attr_reader :last_response
+    attr_accessor :host, :port, :path, :sleep, :timeout
+        
+    include HTTP
+    include SNMP
+    include SMTP
+    include Reporting
+    include TCPSimple
+    include Defaults
+    include TestCommands
+    
+    def initialize
+      @host = ''
+      @port = nil
+      @path = ''
+      
+      @sleep = 60
+      @timeout = 5
+      
+      @responses = {}
+      @downtimers = {}
+      @last_downtime = {}
+      @responses_limit = 10
+      @last_response = ''
+      
+      @localhost = 'localhost'
+    end
+
+    # Returns the current time in the same format
+    #
+    def time ; Time.now.utc ; end
+
+    # Used to define the current host for this command.
+    def current_host ; @host ; end
+    
+    # The status of the last task against the service.
+    def status ; @last_response.code; end
+    
+    # Set the port the service you're monitoring runs on.
+    def port(port) ; @port = port ; end
+
+    # Define the timeout and frequency for a task.
+    def timeout(timeout) ; @timeout = to_seconds timeout ; end
+    def frequency(sleep)
+      @sleep = to_seconds sleep
+      @timeout = @sleep - 1 if !@timeout or @sleep > @timeout
+    end
+
+    ##
+
+    # Call on_up or on_down with a block to define an event:
+    #
+    # Example:
+    #
+    # on_up do
+    #   logger.info("#{current_host} came back!")
+    # end
+    #
+    #
+    def on_down(&block)
+      @on_down = block
+    end
+    
+    def on_up(&block)
+      @on_up = block
+    end
+    
+    # Get the downtime for this task.
+    def down_for
+      if @downtimers[@host].nil?
+        return @last_downtime[@host] || 0
+      else
+        return time.to_i - @downtimers[@host].to_i
+      end
+    end
+
+    # Called when a task has reported a service offline.
+    def down
+      if @downtimers[@host].nil?
+        @downtimers[@host] = time
+        @last_downtime[@host] = 0
+        @on_down.call(self) if @on_down
+      end
+    end
+
+    # Called when a task has seen the service come back.
+    def up
+      if @downtimers[@host]
+        @last_downtime[@host] = time.to_i - @downtimers[@host].to_i
+        @downtimers[@host] = nil
+        @on_up.call(self) if @on_up
+      end
+    end
+
+    def respond_to?(sym) #:nodoc:
+      self.methods.include?(sym) || super
+    end
+    
+    private
+
+    # Store the remote responses in queue.
+    def add_response(name, response, down = false)
+      @last_response = response
+      
+      down ? self.down : up
+      
+      @responses[@host] ||= []
+      @responses[@host].insert 0, {:name => name, :response => response, :time => time, :down => down }
+      @responses[@host].pop if @responses[@host].size > @responses_limit
+    end
+
+    def to_seconds(argument)
+      return argument if argument.class < Integer
+
+      if argument.class == String
+        case argument
+          when /^(.*?)[+,](.*)$/                     then to_sec($1) + to_sec($2)
+          when /^\s*([0-9_]+)\s*\*(.+)$/             then $1.to_i * to_sec($2)
+          when /^\s*[0-9_]+\s*(s(ec(ond)?s?)?)?\s*$/ then argument.to_i
+          when /^\s*([0-9_]+)\s*m(in(ute)?s?)?\s*$/  then $1.to_i *      60
+          when /^\s*([0-9_]+)\s*h(ours?)?\s*$/       then $1.to_i *    3600
+          when /^\s*([0-9_]+)\s*d(ays?)?\s*$/        then $1.to_i *   86400
+          when /^\s*([0-9_]+)\s*w(eeks?)?\s*$/       then $1.to_i *  604800
+          when /^\s*([0-9_]+)\s*months?\s*$/         then $1.to_i * 2419200
+          else                                       0
+        end
+      end
+    end
+  end
+end

data/lib/inari/configuration.rb

@@ -0,0 +1,128 @@
+module Inari
+  # Loads the tasks file and defines task manager to carry out the tasks
+  class Configuration
+    include Singleton
+    
+    Server = Struct.new(:host, :options)
+    
+    # The TaskManager created for this configuration instance.
+    attr_reader :taskmanager
+
+    # The load paths used for locating recipe files.
+    attr_reader :load_paths, :default_load_path
+
+    # The hash of servers.
+    attr_reader :servers 
+    
+    # The hash of global options.
+    attr_reader :options 
+
+    def initialize() #:nodoc:
+      @servers = Hash.new { |h, k| h[k] = [] }
+      @options = Hash.new { |h, k| h[k] = [] }
+      @default_load_path = File.join(Config::CONFIG['prefix'], 'etc')
+      @load_paths = ['.', @default_load_path]
+      @now = Time.now.utc
+      @taskmanager = TaskManager.instance
+    end
+
+    # Load a configuration file or string into this configuration.
+    #
+    # Usage:
+    #
+    #   load(:file => "settings.conf"):
+    #     Load a configuration file.
+    #
+    #   load(:string => "set :scm, :subversion"):
+    #     Load the given string as a configuration specification.
+    #
+    #   load { ... }
+    #     Load the block in the context of the configuration.
+    def load(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each { |arg| load options.merge(:file => arg) }
+      return unless args.empty?
+
+      if block
+        raise 'Loading a block requires 2 parameters' unless args.empty?
+        load(options.merge(:proc => block))
+
+      elsif options[:file]
+        file = options[:file]
+        unless file[0] == ?/
+          load_paths.each do |path|
+            if File.file?(File.join(path, file))
+              file = File.join(path, file)
+              break
+            end
+          end
+          
+          raise ArgumentError, "Configuration file #{file} not found." if file.nil?
+        end
+
+        load :string => File.read(file), :name => options[:name] || file
+
+      elsif options[:string]
+        instance_eval(options[:string], options[:name] || "<eval>")
+
+      elsif options[:proc]
+        instance_eval(&options[:proc])
+
+      else
+        raise ArgumentError, "Don't know how to load #{options.inspect}"
+      end
+    end
+
+    # Define a new server and its associated servers. You must specify at least
+    # one host for each server. 
+    #
+    # Usage:
+    #
+    #   server :db, 'db1.example.com', 'db2.example.com'
+    #   server :mail, 'mail.example.com'
+    def server(which, *args)
+      raise ArgumentError, 'must give at least one host' if args.empty?
+      args.each { |host| servers[which] << Server.new(host) }
+    end
+    
+    def config(field, *args)
+      @options[field] = args
+    end
+
+    # Describe the next task to be defined.
+    def desc(text)
+      @next_description = text
+    end
+    
+    # Returns the logging object
+    def logger
+      Inari::logger
+    end
+
+    # Define a new task. If a description is active (see #desc), it is added to
+    # the options under the <tt>:desc</tt> key. This method ultimately
+    # delegates to TaskManager#define_task.
+    def task(name, options={}, &block)
+      raise ArgumentError, 'expected a block' unless block
+      
+      if @next_description
+        options = options.merge(:desc => @next_description)
+        @next_description = nil
+      end
+
+      taskmanager.define_task(name, options, &block)
+    end
+    
+    def run_tasks
+      taskmanager.run_tasks
+    end
+
+    def method_missing(sym, *args, &block) #:nodoc:
+      if args.length == 0 && block.nil? && @variables.has_key?(sym)
+        self[sym]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/inari/daemon.rb

@@ -0,0 +1,98 @@
+# http://www.bigbold.com/snippets/posts/show/2265
+#
+
+require 'fileutils'
+
+module Daemon
+  def self.exit?
+    !ARGV.empty? and ARGV[0] == 'stop'
+  end
+
+  class Base
+    def self.pid_file_name
+      File.join(Dir.tmpdir, 'inari.pid')
+    end
+    
+    def self.daemonize
+      Controller.daemonize(self)
+    end
+  end
+  
+  module PidFile
+    def self.store(daemon, pid)
+      File.open(daemon.pid_file_name, 'a+') {|f| f << pid.to_s + "\n"}
+    end
+    
+    def self.recall(daemon)
+      IO.read(daemon.pid_file_name).split("\n").collect {|pid| pid.to_i } rescue nil
+    end
+  end
+  
+  module Controller
+    def self.daemonize(daemon)
+      case !ARGV.empty? && ARGV[0]
+      when 'start'
+        start(daemon)
+      when 'stop'
+        puts 'Cleaning up all processes.'
+        stop(daemon)
+        puts 'Stopped.'
+        exit
+      when 'restart'
+        stop(daemon)
+        start(daemon)
+      else
+        puts 'Invalid command. Please specify start, stop or restart.'
+        exit
+      end
+    end
+
+    # Create a process for this task.
+    def self.start(daemon)
+      fork do
+        # Become session leader
+        Process.setsid
+        # Zap session leader
+        exit if fork
+        # Store the pid
+        PidFile.store(daemon, Process.pid)
+        # Change directory
+        Dir.chdir Dir.tmpdir
+        
+        redirect_logs if ARGV.empty? and ARGV[1] != 'debug'
+        
+        trap('TERM') {daemon.stop; exit}
+        daemon.start
+      end
+    end
+    
+    # Stop all tasks.
+    def self.stop(daemon)
+      puts 'Stopping all tasks...'
+      
+      if !File.file?(daemon.pid_file_name)
+        puts "Pid file not found (#{daemon.pid_file_name}). Is the daemon running?"
+        exit
+      end
+      (PidFile.recall(daemon) or []).each do |pid|
+        pid && Process.kill('TERM', pid) rescue Errno::ESRCH
+      end
+      remove_pid_file(daemon)
+      
+      puts 'Tasks stopped.'
+    end
+    
+    def self.remove_pid_file(daemon)
+      FileUtils.rm(daemon.pid_file_name)
+    end
+    
+    private
+  
+    def self.redirect_logs
+      # Free file descriptors and point them somewhere sensible.
+      STDIN.reopen '/dev/null'
+      STDOUT.reopen '/dev/null', 'a'
+      STDERR.reopen STDOUT
+    end
+  end
+end

data/lib/inari/response.rb

@@ -0,0 +1,9 @@
+class Response
+  attr_accessor :code
+  attr_accessor :size
+  attr_accessor :logged
+  
+  def initialize(*args)
+    args.each { |field, value| self.send(field, value) } if args.is_a? Hash
+  end
+end

data/lib/inari/task_manager.rb

@@ -0,0 +1,78 @@
+module Inari
+  class TaskManager
+    include Singleton
+    
+    # The command library associated with this TaskManager.
+    attr_reader :commands
+
+    # A hash of the tasks known to this TaskManager, keyed by name. The values are
+    # instances of TaskManager::Task.
+    attr_reader :tasks
+    
+    # Represents the definition of a single task.
+    class Task #:nodoc:
+      attr_reader :name, :taskmanager, :options, :hosts
+      
+      def initialize(name, taskmanager, options)
+        @name, @taskmanager, @options = name, taskmanager, options
+      end
+      
+      # Returns the list of servers that are the target of this task.
+      def hosts
+        unless @hosts
+          servers = [*(@options[:servers] || Inari::configuration.servers.keys)].map do |name|
+            if Inari::configuration.servers[name].size == 0
+              raise ArgumentError, "Task: #{self.name.inspect} references non-existent or invalid server: #{name.inspect}."
+            else
+              Inari::configuration.servers[name]
+            end 
+          end
+          @hosts = servers.flatten.map { |server| server.host }.uniq
+        end
+        @hosts
+      end
+    end
+    
+    def initialize #:nodoc:
+      @commands = Commands.instance
+      @tasks = {}
+    end
+
+    # Define a new task for this TaskManager. The block will be invoked when this task is called.
+    def define_task(name, options={}, &block)
+      @tasks[name] = (options[:task_class] || Task).new(name, self, options)
+      define_method(name) do
+        send "before_#{name}" if respond_to? "before_#{name}"
+        result = instance_eval(&block)
+        send "after_#{name}" if respond_to? "after_#{name}"
+        result
+      end
+    end
+   
+    def run_tasks
+      tasks.each do |task|
+        TaskProcess.daemonize(self, task)
+      end
+    end
+
+    def metaclass
+      class << self; self; end
+    end
+   
+    private
+    
+      def method_missing(sym, *args, &block)
+        if Inari::configuration.respond_to?(sym)
+          Inari::configuration.send(sym, *args, &block)
+        elsif @commands.respond_to?(sym)
+          @commands.send(sym, *args, &block)
+        else
+          super
+        end
+      end
+    
+      def define_method(name, &block)
+        metaclass.send(:define_method, name, &block)
+      end
+  end
+end

data/lib/inari/task_process.rb

@@ -0,0 +1,46 @@
+module Inari
+  # Starts a process that runs a task.
+  #
+  class TaskProcess < Daemon::Base
+    @@taskmanager, @@task = ''
+
+    def self.start
+      Inari::logger.info "Monitoring started for task #{@@task[0]}"
+      semaphore = Mutex.new
+      
+      # Run threads for each host
+      threads = []
+      @@task[1].hosts.each do |host|
+        threads << Thread.new do
+          loop do
+            semaphore.synchronize do
+              begin
+                @@taskmanager.commands.host = host
+                @@taskmanager.send(@@task[0])
+              rescue Timeout::Error
+                # Potential network timeout issue
+                @@taskmanager.commands.down
+              end
+            end
+            
+            sleep @@taskmanager.commands.sleep
+          end
+        end
+      end
+
+      threads.each do |thread|
+        thread.join
+      end
+    rescue ArgumentError
+      Daemon::Controller.remove_pid_file(self)
+      raise
+    end
+
+    def self.daemonize(taskmanager, task)
+      @@taskmanager, @@task = taskmanager, task
+      Daemon::Controller.daemonize(self)
+    end
+
+    def self.stop ; end
+  end
+end

data/lib/inari/version.rb

@@ -0,0 +1,9 @@
+
+module Inari
+  APP_NAME = 'Inari'
+  
+  INARI_VERSION = '0.1.0'
+  INARI_RELEASE_DATE = '2007/02/06'
+
+  UPSTREAM_URL = 'http://inari.rubyforge.org'
+end

data/lib/inari.rb

@@ -0,0 +1,44 @@
+require 'rbconfig'
+require 'rubygems'
+require 'enumerator'
+require 'socket'
+require 'net/smtp'
+require 'timeout'
+require 'singleton'
+require 'logger'
+require 'tmpdir'
+
+# Inari's classes and modules
+require 'inari/daemon'
+require 'inari/commands'
+require 'inari/task_manager'
+require 'inari/configuration'
+require 'inari/task_process'
+
+module Inari
+  def self.logger #:nodoc:
+    unless defined? @@logger
+      Dir.chdir Dir.tmpdir do
+        @@logger = Logger.new('inari.log')
+        @@logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+      end
+    end
+    
+    @@logger
+  end
+  
+  def self.configuration #:nodoc:
+    Inari::Configuration.instance
+  end
+  
+  def self.go
+    unless Daemon::exit?
+      logger.info '*** Inari started'
+      configuration.load(ARGV[1] || 'inari.conf')
+      configuration.run_tasks
+    else
+      Daemon::Controller.stop(Daemon::Base)
+      logger.info '*** Inari stopped'
+    end
+  end
+end

data/test/abstract_test.rb

@@ -0,0 +1,4 @@
+# Generic test requirements
+
+require 'test/unit'
+require 'inari'

data/test/commands_test.rb

@@ -0,0 +1,41 @@
+require 'test/abstract_test'
+
+class CommandsTest < Test::Unit::TestCase
+  def setup
+    @commands = Inari::Commands.instance
+  end
+  
+  def test_down_time
+    @commands.host = 'test'
+    @commands.down
+    sleep 1
+    @commands.up
+    
+    assert_equal 1, @commands.down_for
+  end
+  
+  def test_multiple_down_time
+    ['localhost', 'test.localhost', 'test2.localhost'].each do |host|
+      @commands.host = host
+      @commands.down
+    end
+    
+    @commands.host = 'test3.localhost'
+    @commands.down
+
+    sleep 1
+
+
+    ['localhost', 'test.localhost', 'test2.localhost'].each do |host|
+      @commands.host = host
+      @commands.up
+      
+      assert_equal 1, @commands.down_for
+    end
+    
+    sleep 1
+    
+    @commands.host = 'test3.localhost'
+    assert_equal 2, @commands.down_for
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,19 @@
+require 'test/abstract_test'
+
+class ConfigurationTest < Test::Unit::TestCase
+  def setup
+    @configuration = Inari::Configuration.instance
+  end
+  
+  # Check if any of the load paths make sense
+  def test_default_load_path_exists
+    assert File.directory?(@configuration.default_load_path)
+  end
+  
+  def test_loads
+    @configuration.load_paths.push 'test/fixtures/'
+    assert_nil @configuration.load('test_config.rb')
+    assert_equal 3, @configuration.servers.size
+    assert_kind_of Inari::Configuration::Server, @configuration.servers[:local].first
+  end
+end

data/test/fixtures/test_config.rb

@@ -0,0 +1,25 @@
+# Configuration
+config :email_to, 'alex@example.com'
+config :email_from, 'alex@example.com'
+
+# Server definitions
+#
+# Define a name for each server so your tasks can refer to them, and
+# provide the server's hostname.  You can supply more than one
+# address for each name.
+
+server :local, 'localhost'
+server :web_misc, 'helicoid.net', 'alexyoung.org'
+server :blogs, 'blog.helicoid.net', 'work.alexyoung.org'
+
+# Task definitions
+#
+# Tasks are units of tests to run against each server.
+# Tasks may run against more than one server by providing a list of definitions.
+
+desc 'Defaults example: logger'
+task :example, :servers => [:local, :web_misc, :blogs] do
+  get_web_page '/'
+  frequency '30 seconds'
+  log_on_events
+end

data/test/task_manager_test.rb

@@ -0,0 +1,28 @@
+require 'test/abstract_test'
+
+class TaskManagerTest < Test::Unit::TestCase
+  def setup
+    @configuration = Inari::Configuration.instance
+    @configuration.load_paths.push 'test/fixtures/'
+    @configuration.load('test_config.rb')
+  end
+
+  def test_task_definitions
+    @configuration.taskmanager.define_task(:example2, {}, &Proc.new { port 80 ; up? })
+    
+    # Define the method
+    assert_nil @configuration.taskmanager.tasks[:example2].options[:desc]
+    
+    # Run it
+    @configuration.taskmanager.send(:example2)
+  end
+
+  def test_loaded_tasks
+    # The loaded configuration should result in one task
+    assert_equal 1, @configuration.taskmanager.tasks.size
+    
+    # Check fields are set correctly and where expected
+    assert_equal 'Defaults example: logger', @configuration.taskmanager.tasks[:example].options[:desc]
+    assert_kind_of Array, @configuration.taskmanager.tasks[:example].options[:servers]
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: inari
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-02-06 00:00:00 +00:00
+summary: Inari is a ruby system monitoring program.
+require_paths: 
+- lib
+email: alex@helicoid.net
+homepage: http://inari.rubyforge.org
+rubyforge_project: inari
+description: 
+autorequire: inari
+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
+signing_key: 
+cert_chain: 
+post_install_message: |+
+  
+  Welcome to Inari
+  ================
+  
+  Inari is a small and extenable system monitor, intended for us with
+  web applications.  To start using it, tailor /usr/local/etc/inari.conf
+  to your requirements.
+  
+  Take a look at README for help on writing configuration files.
+  
+  http://inari.rubyforge.org
+  
+authors: []
+
+files: 
+- lib/inari.rb
+- lib/inari/commands.rb
+- lib/inari/configuration.rb
+- lib/inari/daemon.rb
+- lib/inari/response.rb
+- lib/inari/task_manager.rb
+- lib/inari/task_process.rb
+- lib/inari/version.rb
+- lib/inari/commands/defaults.rb
+- lib/inari/commands/http.rb
+- lib/inari/commands/reporting.rb
+- lib/inari/commands/smtp.rb
+- lib/inari/commands/snmp.rb
+- lib/inari/commands/tcp_simple.rb
+- lib/inari/commands/test.rb
+- bin/inari
+- CHANGES
+- InstalledFiles
+- LICENSE
+- Rakefile
+- README
+- THANKS
+- test/abstract_test.rb
+- test/commands_test.rb
+- test/configuration_test.rb
+- test/fixtures
+- test/task_manager_test.rb
+- test/fixtures/test_config.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- inari
+extensions: []
+
+requirements: 
+- logger
+dependencies: []
+