reckoner 0.4.0

data/History.txt

@@ -0,0 +1,9 @@
+=== 0.2.0 / 2009-06-19
+
+* Still more to do:
+  * Break out the stuff from bin/reckoner into class so that it 
+    be tested more easily.
+
+  * Add some more checks
+
+

data/Manifest.txt

@@ -0,0 +1,22 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/reckoner
+lib/main.rb
+lib/reckoner.rb
+lib/abstract_check.rb
+lib/rfile.rb
+lib/sendmail.rb
+lib/sample.rb
+lib/standard_checks.rb
+test/support.rb
+test/test_abstract_check.rb
+test/test_exist.rb
+test/test_freshness.rb
+test/test_main.rb
+test/test_minimum_size.rb
+test/test_rfile.rb
+test/test_support.rb
+test/files/one-k.bin
+test/files/additional_checks.rb

data/README.txt

@@ -0,0 +1,67 @@
+= reckoner
+
+* http://reckoner.rubyforge.com
+
+== DESCRIPTION:
+
+Ruby Reckoner is an easily-configurable program that monitors
+files and can send notifications when it finds problems.
+
+Currently it can only check that files exist, have been updated
+recently and that they have a minimum size, however it is easy to add
+your own checks written in Ruby.
+
+== FEATURES/PROBLEMS:
+
+* Easy YAML Configuration
+* Check for file existence, freshness and size
+* Easy to add your own checks
+
+== USAGE:
+
+reckoner [OPTIONS] [CONFIG FILE]
+
+Reckoner will read its configuration information from either
+the CONFIG FILE argument or from stdin.
+
+*Options*
+
+  -d --debug Output debugging information
+
+  -q --quiet Suppress the check output
+
+  -c --checks=FILE Specifies a Ruby file that contains
+  additional checks that can be performed.
+
+== REQUIREMENTS:
+
+* Ruby
+
+== INSTALL:
+
+* sudo gem install reckoner
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Geoff Kloess
+
+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/Rakefile

@@ -0,0 +1,11 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'reckoner' do
+  # self.rubyforge_name = 'reckonerx' # if different than 'reckoner'
+  self.developer('Geoff Kloess', 'geoff.kloess@gmail.com')
+end
+
+# vim: syntax=ruby

data/bin/reckoner

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+require 'main'
+
+main = Main.new(ARGV)
+output = main.run_reckoner
+puts output if output

data/lib/abstract_check.rb

@@ -0,0 +1,86 @@
+require 'find'
+
+# The parent class of all checks.  It provides all necessary
+# logic except for the check itself.
+class AbstractCheck
+  attr_reader :errors
+  attr_reader :path
+  @@classes = []
+
+  def self.inherited(c)
+    @@classes << c
+  end
+
+  def self.children
+    return @@classes
+  end
+
+  def self.check_name(name)
+    self.class_eval("def self.get_check_name; '#{name}'; end")
+  end
+
+  # Returns the name of the check.  By default it un-camel-cases the class 
+  # name. (Code taken from the underscore method of Rails' Inflector Module.)
+  def self.get_check_name
+    self.name.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+  # Performs simple unit parsing of strings of the form "[number] [units]".
+  #
+  # The unit hash contains a hash where the keys are regular expressions
+  # that match a unit.  Each value is a factor that will be multiplied against
+  # the parsed number.
+  #
+  # Example converting to inches (12 inches = 1 foot):
+  # uhash = { /^inch/ => 1, /^feet/ => 12, /^foot/ => 12, 'default' => 1}
+  #
+  # * AbstractCheck.unit_parse("1",uhash) #=> 1
+  # * AbstractCheck.unit_parse("1 inch",uhash) #=> 1
+  # * AbstractCheck.unit_parse("1 foot",uhash) #=> 12
+  # * AbstractCheck.unit_parse("2 feet",uhash) #=> 24 inches
+  #
+  def unit_parse(content,unit_hash)
+    m = /(\d*\.?\d+)\s*(.*)/.match content
+    raise "Could not parse '#{content}'" unless m
+    if m.length == 2
+      factor = unit_hash['default'] || 1
+    elsif m.length == 3
+      key,factor = unit_hash.detect{|key,value| key.match(m[2])}
+      raise "Invalid unit in '#{content}'" unless factor
+    end
+    if /\./.match m[1]
+      m[1].to_f * factor
+    else
+      m[1].to_i * factor
+    end
+  end
+
+  # Creates the check object, requires a path to check as the argument.
+  def initialize(file_path)
+    @errors = []
+    @path = RFile.new(file_path)
+  end
+
+  # Called by the Recokoner class to run the check
+  def run_check(options)
+    check(@path,options)
+  end
+
+  # Adds an error message for this check.  Use this if your check finds that
+  # the check is invalid.
+  def add_error(msg)
+    @errors << "#{self.class.get_check_name.capitalize} found a problem with '#{@path.path}': #{msg}"
+  end
+
+  # Override this method to perform your custom check.  Its first argument is
+  # a RFile path object, the second argument is any options passed in along with the
+  # check in the YAML file.
+  def check(path_obj,options)
+    raise "Called abstract methd: check"
+  end
+
+end

data/lib/main.rb

@@ -0,0 +1,141 @@
+require 'net/smtp'
+require 'rubygems'
+require 'yaml'
+require 'optparse'
+require 'ftools'
+
+require 'rfile.rb'
+require 'abstract_check.rb'
+require 'reckoner'
+require 'sendmail'
+require 'sample'
+
+=begin rdoc
+The Main class ties together the core Reckoner functionality
+with the command line arguments, configuration file and email.
+=end
+
+class Main
+  include SampleFile
+
+  DEFAULT_ARGUMENTS = {
+    'debug' => false,
+    'quiet' => false,
+    'extra_checks' => [],
+    'sample' => nil,
+    'email' => true
+  }
+
+  def self.error_out(message)
+    STDERR.puts "Aborting Reckoner operations!"
+    STDERR.puts message
+    exit 1
+  end
+
+  def initialize(argv)
+    @argv = argv
+    @arguments = DEFAULT_ARGUMENTS.dup
+    @opt_parser = OptionParser.new do |o|
+      o.banner = "Usage: #{$0} [options] [config_file]"
+      o.on('-d', '--debug', 'Output debugging information')  do |d|
+        @arguments['debug'] = d
+      end
+      o.on('-q', '--quiet', 'Do not print final report') do |q|
+        @arguments['quiet'] = q
+      end
+      o.on('-e', '--email-off', 'Do not send email, even if configured') do |q|
+        @arguments['email'] = !q
+      end
+      o.on('-c','--checks=FILE', 'Additional checks file') do |c|
+        @arguments['extra_checks'] << c
+      end
+      o.on('-s FILE','--sample-config FILE', 'Create a sample config named FILE') do |sample|
+        @arguments['sample'] = sample
+      end
+    end
+    @opt_parser.parse!(@argv)
+  end
+
+  def run_reckoner
+    if @arguments['sample']
+      return(make_sample_file(@arguments['sample']))
+    end
+
+    if @argv.length > 1
+      Main.error_out "Aborting Reckoner: Too many arguments\n" + @opt_parser.help
+    end
+
+    if @argv.empty?
+      config_file = STDIN.read
+    else
+      config_file = File.read(@argv[0])
+    end 
+
+    run_config(config_file)
+  end
+
+  def run_config(config_file)
+    begin
+      yaml_tree = YAML::load(config_file)
+    rescue ArgumentError => e
+      Main.error_out "There was an error parsing the YAML configuration file."
+    end
+
+    cm = Reckoner.new(@arguments['extra_checks'],@arguments['debug'])
+    cm.check(yaml_tree['check'])
+
+    if yaml_tree['mail'] && @arguments['email']
+      send_email( cm, yaml_tree['mail'])
+    end
+
+    if @arguments['quiet']
+      return nil
+    else
+      return output_results(cm)
+    end
+  end
+
+  def send_email(cm,mail_config)
+    raise "Mail section must have a 'to' parameter" unless mail_config['to']
+    mailobj = Sendmail.new(mail_config['sendmail_path'],
+                           mail_config['sendmail_options'])
+
+    from = mail_config['from'] || ENV['USER']
+    always_mail = mail_config['always_mail'] || true
+    subject = mail_config['subject_prefix'] || 'Reckoner:'
+    subject.strip!
+    subject << ' '
+
+    if !cm.errors.empty?
+      subject << "Found #{cm.errors.length} problem(s)"
+      body = cm.errors.join("\n")
+      mailobj.send(mail_config['to'],from,subject,body)
+    elsif always_mail
+      subject << "No problems found"
+      body = "No problems found"
+      mailobj.send(mail_config['to'],from,subject,body)
+    end
+  end
+
+  def output_results(cm)
+    s = String.new
+    if cm.errors.empty?
+      s = "No failed checks"
+    else
+      s = "#{cm.errors.length} problem(s) found!\n"
+      cm.errors.each do |err|
+        s << err + "\n"
+      end
+    end
+    return s
+  end
+
+  def make_sample_file(file_name)
+    out = File.open(file_name,'w')
+    out.write SAMPLE_CONFIGURATION_FILE
+    out.close
+    "Generated file #{file_name}"
+  end
+
+  
+end

data/lib/reckoner.rb

@@ -0,0 +1,99 @@
+
+=begin rdoc
+The Reckoner class is intialized with the configuration information, 
+loads the checks and performs them.
+=end
+class Reckoner
+ VERSION = '0.4.0'
+
+  attr_accessor :debug
+  attr_reader :errors
+
+  # Creates the class.  The first argument is an array of custom check files, 
+  # if any. The debug arguments determines whether or not debugging information 
+  # will be printed out during execution.
+  def initialize(custom_check_files = nil,debug = false)
+    @debug = debug
+    @errors = []
+    @registered_checks = {}
+    load_checks(custom_check_files)
+  end
+
+  # Loads the checks from the standard_checks file and the 
+  def load_checks(custom_check_files)
+    #load the standard checks
+    require 'standard_checks.rb'
+
+    #load the custom check files from the arguments
+    custom_check_files.each{|f| require f } if custom_check_files
+
+    AbstractCheck.children.each do |chk|
+      @registered_checks[chk.get_check_name] = chk
+    end
+  end
+
+  # Goes through the passed in check hash and begins the checking
+  # process.  Ensures that the files exist before the other checks 
+  # are called.
+  def check(check_hash)
+    unless check_hash
+      raise "No checks to perform - check that your configuration " +
+            "file is formatted correctly"
+      return
+    end
+
+    default_checks = check_hash.delete('default_check') || {}
+    puts "Using defaults: #{default_checks.inspect}" if @debug && !default_checks.empty?
+
+    check_hash.each do |block,checks|
+      puts "\n'#{block}'" if @debug
+
+      checks = default_checks.merge(checks)
+      puts "  checks: #{checks.inspect}" if @debug
+
+      files = checks.delete('files') || checks.delete('file')
+      unless files
+        raise "No file entries found in block '#{block}'"
+      end      
+
+      base_path = checks.delete('base_path')
+
+      files.each do |f|
+        if base_path
+          file_path = File.join(base_path,f.strip)
+        else
+          file_path = f.strip
+        end
+        if File.exists?(file_path) && File.readable?(file_path)
+          puts "  Checking file '#{file_path}'" if @debug
+          run_checks(block,file_path,checks)
+        else
+          @errors << "Reckoner found a problem with '#{file_path}': file " +
+                     "does not exist or is not readable by this user"
+        end   
+      end
+    end
+  end
+
+  private
+
+  # Runs a set of checks on a file path
+  def run_checks(block,file_path,checks)
+    checks.each do |chk|
+      puts "  Running check #{chk.inspect} on #{file_path}" if @debug
+
+      check_name = chk[0]
+      check_options = chk[1]
+
+      if @registered_checks[check_name]
+        check_obj = @registered_checks[check_name].new(file_path)
+        check_obj.run_check(check_options.to_s)
+        @errors = @errors + check_obj.errors
+      else
+        raise "Invalid check name: #{check_name},  " + 
+              "Known checks: #{@registered_checks.keys.join(', ')}"
+      end
+    end
+  end
+
+end

data/lib/rfile.rb

@@ -0,0 +1,91 @@
+
+# RFile provides a unified and easy way to check various 
+# attributes of a specific file or path.  It provides simple
+# access to various methods from the core File class.
+#
+# It also offers several methods that provide simplified
+# Find functionality.
+class RFile
+  attr_reader :path
+
+  %w(<=> atime blksize blockdev? blocks chardev? ctime 
+     dev dev_major dev_minor directory? executable? executable_real? 
+     file? ftype gid grpowned? ino inspect mode mtime new nlink owned? pipe? 
+     pretty_print rdev rdev_major rdev_minor readable? readable_real? 
+     setgid? setuid? size size? socket? sticky? symlink? uid writable? 
+     writable_real? zero?).each do |m|
+    define_method m do |*args|
+      stat.send m, *args
+    end
+  end
+
+  %w(basename dirname expand_path extname lstat ).each do |m|
+    define_method m do 
+      File.send m, @path
+    end
+  end
+
+  # Lazy loading of the stat object.
+  def stat
+    unless instance_variables.include?(:stat)
+      @stat = File.stat(@path)
+    end
+    @stat
+  end
+
+  def initialize(path)
+    @path = path
+  end
+
+  def to_s
+    @path
+  end
+
+  def sub_nodes(options = {})
+    opts = { :directories => true,
+             :files => true }.merge(options)
+    Find.find(@path) do |path|
+       if ((File.file?(path) && opts[:files]) ||
+           (File.directory?(path) && opts[:directories]))
+         yield RFile.new(path)
+       end
+    end
+  end
+
+  # Loops through all sub-directories and yields to a block
+  # for each node, passing in an RFile object for the current path.  
+  # Returns true if any yield returns true, otherwise returns false.  
+  #
+  # Useful for efficiently determining if any
+  # sub-directories or their files meet a user-defined criteria.
+  def any_sub_node?(options={})
+    sub_nodes(options) do |rf|
+      return true if yield(rf)
+    end
+    return false
+  end
+
+  # Loops through all sub-directories and yields to a block
+  # for each node, passing in an RFile object for the current path.  
+  # Returns true if all yields returns true, otherwise returns false.  
+  #
+  # Useful for efficiently determining if any
+  # sub-directories or their files meet a user-defined criteria.
+  def all_sub_nodes?(options={})
+    sub_nodes(options) do |rf|
+      return false unless yield(rf)
+    end
+    return true
+  end
+
+  # Returns an array with an RFile object for every sub-directory
+  # and file below the current path.
+  def sub_node_array(options={})
+    a = Array.new
+    sub_nodes(options) do |rf|
+      a << rf
+    end
+    return a
+  end
+
+end

data/lib/sample.rb

@@ -0,0 +1,55 @@
+module SampleFile
+SAMPLE_CONFIGURATION_FILE = <<SAMPLE
+# SAMPLE RECKONER CONFIGURATION FILES
+# Reckoner uses a YAML formatted file to define the checks
+# that it should preform.  The file has two sections,
+# the 'check' section and the 'mail' section.
+
+# The check section contains a list of check blocks, each 
+# of which defines one set of checks.
+check:
+
+  # Define default settings for all of your check blocks.
+  # This default check sets my home directory as a default
+  # base path for my checks.
+  #
+  # The default_check block is not required.
+  default_check:
+    base_path: /home/geoffk
+
+  # This is the simplest possible check.  It simply ensures
+  # that there exists a file named '.bash_history'.  Since this
+  # checks doesn't overwrite the default 'base_path' it will
+  # check for this file in '/home/geoffk'
+  geoff_check:
+    files: .bash_history
+
+  # This check block, named 'etc-files', sets it's own base
+  # path of '/etc' and then checks that two files,
+  # 'redhat-release' and 'inittab', exist there.  Note the
+  # use of square brackets and the comma to make a list of files.
+  etc-files:
+    base_path: /etc
+    files: [fake-file, inittab]
+
+  # This check ensures that two files exist and that they be 
+  # at least 1kb in size and have been updated in the last
+  # three days. 
+  desktop-files:
+    base_path: /home/geoffk/Desktop
+    files: [bookmarks.html, songs.txt]
+    freshness: 3 days
+    minimum_size: 1 kb
+
+# The mail section is required for email notifications.  The only
+# required setting inside the mail section is 'to'. 
+mail:
+  to: DESTINATION EMAIL ADDRESS
+  #from: defaults to current user 
+  #subject_prefix: "RECKONER:"
+  #sendmail_path: sendmail
+  #sendmail_options: -i -t
+  #always_email: true
+
+SAMPLE
+end

data/lib/sendmail.rb

@@ -0,0 +1,28 @@
+
+# Provides sendmail functionality for the reckoner script.
+class Sendmail
+
+  # Creates the class with a path to the binary (if any is
+  # given) and options.
+  def initialize(path,options)
+    @path = path
+    @options = options
+  end
+
+  #Sends the email. 
+  def send(to,from,subject,message)
+    path = @path || 'sendmail'
+    options = @options || '-i -t'
+
+    cmd = %|#{path} #{options}|
+
+    body = "To: #{to}\n"
+    body << "From: #{from}\n"
+    body << "Subject: #{subject}\n"
+    body << "\n#{message}"
+
+    io = IO.popen(cmd,'w')
+    io.puts body 
+    io.close
+  end
+end

data/lib/standard_checks.rb

@@ -0,0 +1,39 @@
+
+
+# Ensures that a file is not too old.
+class Freshness < AbstractCheck
+  SECONDS_IN_HOUR = 60 * 60
+  HOUR_HASH = {'default' => 24, 
+               /^hour/i => 1,
+               /^day/i => 24,
+               /^week/i => 7*24, 
+               /^month/i => 30*24,
+               /^year/i => 365*24}
+
+  def check(path_obj,options)
+    hours = unit_parse(options,HOUR_HASH)
+
+    old_time = Time.now - (hours * SECONDS_IN_HOUR)
+
+    unless path_obj.any_sub_node?{|f| f.mtime > old_time}
+      add_error('file is too old')
+    end
+  end
+end
+
+# Ensures that the size of the file is not
+# too small.
+class MinimumSize < AbstractCheck
+  BYTES_HASH = {'default' => 1,
+                /^b/i => 1,
+                /^kb/i => 1024,
+                /^mb/i => 1024**2,
+                /^gb/i => 1024**3}
+
+  def check(path_obj,options)
+    bytes = unit_parse(options,BYTES_HASH)
+    unless path_obj.size >= bytes
+      add_error("file is too small")
+    end
+  end
+end

data/test/files/additional_checks.rb

@@ -0,0 +1,10 @@
+
+class Extension < AbstractCheck
+
+  def check(path_obj,options)
+    unless path_obj.extname == options.strip
+      add_error 'is not a txt file'
+    end
+  end
+end
+

data/test/support.rb

@@ -0,0 +1,41 @@
+####
+# Offers support for running backup check tests
+
+require 'fileutils'
+
+module BackupCheckSupport
+  include FileUtils
+
+  ROOT = '/tmp/file_verifier_tests'
+
+  #Makes a set of file that meet the specified options
+  def makef(root,name,options = {})
+    mkdir root unless File.exists?(root.to_s)
+    if name.is_a? Hash
+      name.each do |k,n|
+        makef File.join(root,k.to_s),n,options
+      end
+    elsif name.is_a? Array
+      name.each do |n|
+        makef(root,n,options)
+      end
+    elsif name.is_a?(String) || name.is_a?(Symbol)
+      path = File.join(root,name.to_s)
+      touch path
+      File.chmod(options[:chmod],path) if options[:chmod]
+      File.utime(options[:atime],options[:atime],path) if options[:atime]
+    end
+  end
+
+  #Converts days to seconds
+  def d2s(days)
+    days * 24 * 60 * 60
+  end
+
+  #Determines if the object has any errors matching the regular
+  #expression.
+  def has_error(cmain,reg)
+    cmain.errors.any?{|msg| reg.match msg}
+  end
+
+end

data/test/test_abstract_check.rb

@@ -0,0 +1,36 @@
+require 'test/support'
+require 'lib/main'
+require 'test/unit'
+
+class TestCheck < AbstractCheck
+  check_name 'test_check'
+end
+
+class TestCheckTwo < AbstractCheck
+end
+
+class AbstractTest < Test::Unit::TestCase
+  include BackupCheckSupport
+
+  #Test that the name of a test is set correctly and
+  #that it can be over-ridden.
+  def test_abstract_check
+    assert_equal 'test_check', TestCheck.get_check_name
+    assert_equal 'test_check_two', TestCheckTwo.get_check_name
+
+    tc2 = TestCheckTwo.new('.')
+    assert tc2.is_a?(AbstractCheck)
+  end
+
+  def test_unit_parse
+    uhash = { /^inch/ => 1, /^feet/ => 12, /^foot/ => 12, 'default' => 1 }
+    ac = AbstractCheck.new(__FILE__)
+    assert_equal 1, ac.unit_parse("1", uhash)
+    assert_equal 1, ac.unit_parse("1 inch", uhash)
+    assert_equal 1, ac.unit_parse("1inch", uhash)
+    assert_equal 1.5, ac.unit_parse("1.5inch", uhash)
+    assert_equal 12, ac.unit_parse("1 foot", uhash)
+    assert_equal 24, ac.unit_parse("2 feet", uhash)
+  end
+
+end

data/test/test_exist.rb

@@ -0,0 +1,36 @@
+require 'test/support'
+require 'lib/main'
+require 'test/unit'
+
+class ExistsTest < Test::Unit::TestCase
+  include BackupCheckSupport
+
+  def setup
+    @root = '/tmp/test'
+    makef(@root,['one','two','three'])
+  end
+
+  def teardown
+    rm_rf @root
+  end
+
+  def test_files_exist
+    cm = Reckoner.new()
+    cm.check('test'=> {'files'=>'/tmp/test/one'})
+    assert cm.errors.empty?
+
+    cm.check('test'=> {'files'=>['/tmp/test/one','/tmp/test/two']})
+    assert cm.errors.empty?
+    
+    cm.check('test'=> {'base_path'=>'/tmp/test','files'=>['one','two']})
+    assert cm.errors.empty?
+  end
+
+  def test_errors
+    cm = Reckoner.new(nil)
+    cm.check('test'=>{'files'=>'nofile'})
+    assert_equal 1,cm.errors.length
+    assert has_error(cm,/does not exist/)
+  end
+
+end

data/test/test_freshness.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'date'
+require 'test/support'
+require 'lib/main'
+
+class FreshnessTest < Test::Unit::TestCase
+  include BackupCheckSupport
+
+  def setup
+    makef(ROOT,['one','two','three', 
+                 {'dir' => ['four','five']}], :atime => Time.now - d2s(10))
+    makef(ROOT,'six', :atime => Time.now - d2s(1))
+    @cm = Reckoner.new()
+  end
+
+  def teardown
+    rm_rf ROOT
+  end
+
+  def test_single_file_success
+    @cm.check('test'=> {'files'=>File.join(ROOT,'one'), 'freshness' => '20'})
+    assert @cm.errors.empty?
+
+    @cm.check('test'=> {'files'=>File.join(ROOT,'six'), 'freshness' => '30 hours'})
+    assert @cm.errors.empty?
+  end
+
+  def test_single_file_failure
+    @cm.check('test'=> {'files'=>File.join(ROOT,'one'), 'freshness' => '5'})
+    assert_equal 1, @cm.errors.length
+    assert has_error(@cm,/file is too old/)
+  end
+
+  def test_hour_failure
+    @cm.check('test'=> {'files'=>File.join(ROOT,'six'), 'freshness' => '22 hours'})
+    assert_equal 1, @cm.errors.length
+    assert has_error(@cm,/file is too old/)
+  end
+
+  def test_recursive_success
+    hundred_days_ago = Time.now - d2s(100)
+    File.utime(hundred_days_ago,hundred_days_ago,ROOT)
+    assert_equal File.mtime(ROOT).to_s,hundred_days_ago.to_s
+    
+    @cm.check('test'=> {'files'=>ROOT, 'freshness' => '20'})
+    assert @cm.errors.empty?
+  end
+
+end

data/test/test_main.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'date'
+require 'test/support'
+require 'lib/main'
+
+class MainTest < Test::Unit::TestCase
+  include BackupCheckSupport
+
+  def setup
+    makef(ROOT,[{'d1' => ['d1f1', 'd1f2', 'd1f3']},
+                'f4','h1.txt',
+                ['f5', 'f6', 'f7'],
+                {'d2' => ['d2f1', 'd2f2']}])
+    @good_config = <<-CONFIG
+      check:
+        default_check:
+          base_path: #{ROOT}
+        f4:
+          files: f4
+        d1:
+          files: [d1, d1/d1f1]
+    CONFIG
+  end
+
+  def teardown
+    rm_rf ROOT
+  end
+
+  def test_simple
+    m = Main.new([])
+    out = m.run_config(@good_config)
+    assert(/No failed checks/.match(out))
+  end
+
+  def test_sample_config
+    fname = ROOT + '/sample.yaml'
+    m1 = Main.new(['-s',fname])
+    m1.run_reckoner
+    assert File.exists?(fname)
+
+    m2 = Main.new(['-e',fname])
+    out = m2.run_reckoner
+    assert(/Reckoner found a problem with '\/etc\/fake-file'/.match(out))
+    assert out.split("\n").length > 4
+  end
+
+  def test_additional_checks
+    m1 = Main.new(['-c','test/files/additional_checks.rb'])
+    out = m1.run_config <<-CONFIG
+      check:
+        default_check:
+          base_path: #{ROOT}
+        txt:
+          files: [d1, h1.txt]
+          extension: .txt
+     CONFIG
+    assert_equal 2,out.split("\n").length
+    assert(/Extension found a problem with '\/tmp\/file_verifier_tests\/d1'/.match(out))
+  end
+end

data/test/test_minimum_size.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require 'date'
+require 'test/support'
+require 'lib/main'
+
+class MinimumSizeTest < Test::Unit::TestCase
+  include BackupCheckSupport
+
+  def setup
+    @cm = Reckoner.new()
+    @bin = File.join('test','files','one-k.bin')
+  end
+
+  def test_file_right_size
+    @cm.check('test'=> {'files'=>@bin, 'minimum_size' => '1'})
+    assert @cm.errors.empty?
+  end
+
+  def test_file_too_small
+    @cm.check('test'=> {'files'=>@bin, 'minimum_size' => '2048'})
+    assert_equal 1, @cm.errors.length
+    assert has_error(@cm,/file is too small/)
+  end
+
+  def kilobyte_parsing
+    @cm.check('test'=> {'files'=>@bin, 'minimum_size' => '1kb'})
+    assert @cm.errors.empty?
+
+    @cm.check('test'=> {'files'=>@bin, 'minimum_size' => '2kb'})
+    assert_equal 1, @cm.errors.length
+    assert has_error(@cm,/file is too small/)
+  end
+end

data/test/test_reckoner.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require 'date'
+require 'test/support'
+require 'lib/main'
+
+class ReckonerTest < Test::Unit::TestCase
+  include BackupCheckSupport
+
+  def setup
+    makef(ROOT,['one','two','three'], :atime => Time.now - d2s(10))
+    @cm = Reckoner.new()
+  end
+
+  def teardown
+    rm_rf ROOT
+  end
+
+  def test_non_existant_check
+    assert_raise RuntimeError do
+      @cm.check('test'=> {'files'=> File.join(ROOT,'one'), 'nocheck' => '20'})
+    end
+  end
+
+  def test_multiple_files
+    @cm.check('test'=> {'files'=> [File.join(ROOT,'one'), File.join(ROOT,'two')]})
+    assert @cm.errors.empty?
+
+    @cm.check('test'=> {'files'=> [File.join(ROOT,'one'), 
+                                   File.join(ROOT,'blah'),
+                                   File.join(ROOT,'two'),
+                                   File.join(ROOT,'other'),
+                                  ]})
+    assert_equal 2, @cm.errors.length
+    assert(/file does not exist/.match(@cm.errors[0]))
+    assert(/file does not exist/.match(@cm.errors[1]))
+  end
+
+end

data/test/test_rfile.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'date'
+require 'test/support'
+require 'lib/main'
+
+class RFileTest < Test::Unit::TestCase
+  include BackupCheckSupport
+
+  def setup
+    makef(ROOT,[{:d1 => [:f1, :f2, :f3]},
+                {:d2 => [{ :d3 => :f3 }, :f4]}])
+    @cfile = RFile.new(ROOT)
+  end
+
+  def teardown
+    rm_rf ROOT
+  end
+
+  def test_methods
+    assert_equal @cfile.path, ROOT
+    assert_equal @cfile.atime, File.atime(ROOT)
+    assert_equal @cfile.mtime, File.mtime(ROOT)
+    assert_equal @cfile.stat, File.stat(ROOT)
+    assert_equal @cfile.basename, File.basename(ROOT)
+    assert_equal @cfile.expand_path, File.expand_path(ROOT)
+  end
+
+  def test_recurse_functions
+    assert_equal 9, @cfile.sub_node_array.length
+    assert_equal 5, @cfile.sub_node_array(:directories => false).length
+    assert_equal 4, @cfile.sub_node_array(:files => false).length
+
+    assert @cfile.all_sub_nodes?{|f| f.basename.length == 2 || f.directory? } 
+    assert @cfile.any_sub_node?{|f| f.basename == 'f3' } 
+  end
+
+end

data/test/test_support.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'date'
+require 'test/support'
+
+class SupportTest < Test::Unit::TestCase
+  include BackupCheckSupport
+
+  def test_makef
+    makef(ROOT,[{'d1' => ['d1f1', 'd1f2', 'd1f3']},
+                'f4',
+                ['f5', 'f6', 'f7'],
+                {'d2' => ['d2f1', 'd2f2']}])
+
+    assert File.exists?(File.join(ROOT,'d1'))
+    assert File.exists?(File.join(ROOT,'f4'))
+    assert File.exists?(File.join(ROOT,'f5'))
+    assert File.exists?(File.join(ROOT,'f6'))
+    assert File.exists?(File.join(ROOT,'f7'))
+    assert File.exists?(File.join(ROOT,'d1','d1f1'))
+    assert File.exists?(File.join(ROOT,'d1','d1f2'))
+    assert File.exists?(File.join(ROOT,'d1','d1f3'))
+    assert File.exists?(File.join(ROOT,'d2'))
+    assert File.exists?(File.join(ROOT,'d2','d2f1'))
+    assert File.exists?(File.join(ROOT,'d2','d2f2'))
+    rm_rf ROOT
+  end
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: reckoner
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Geoff Kloess
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-02 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.0
+    version: 
+description: |-
+  Ruby Reckoner is an easily-configurable program that monitors
+  files and can send notifications when it finds problems.
+  
+  Currently it can only check that files exist, have been updated
+  recently and that they have a minimum size, however it is easy to add
+  your own checks written in Ruby.
+email: 
+- geoff.kloess@gmail.com
+executables: 
+- reckoner
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/reckoner
+- lib/main.rb
+- lib/reckoner.rb
+- lib/abstract_check.rb
+- lib/rfile.rb
+- lib/sendmail.rb
+- lib/sample.rb
+- lib/standard_checks.rb
+- test/support.rb
+- test/test_abstract_check.rb
+- test/test_exist.rb
+- test/test_freshness.rb
+- test/test_main.rb
+- test/test_minimum_size.rb
+- test/test_rfile.rb
+- test/test_support.rb
+- test/files/one-k.bin
+- test/files/additional_checks.rb
+has_rdoc: true
+homepage: http://reckoner.rubyforge.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: reckoner
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Ruby Reckoner is an easily-configurable program that monitors files and can send notifications when it finds problems
+test_files: 
+- test/test_abstract_check.rb
+- test/test_exist.rb
+- test/test_freshness.rb
+- test/test_main.rb
+- test/test_minimum_size.rb
+- test/test_reckoner.rb
+- test/test_rfile.rb
+- test/test_support.rb