averell23-watchdogger 0.1.0

data/lib/watcher_action/htpost.rb

@@ -0,0 +1,42 @@
+module WatcherAction
+  
+  # This action posts the event to a given URL. It may use plain HTTP Authentication
+  #
+  # Options for this Action:
+  # 
+  #   url          - The URL to post the information to (required)
+  #   user         - The user for HTTP Authentication (optional)
+  #   pass         - The password for HTTP Authentication.
+  class Htpost
+    
+    def initialize(options)
+      @url = options.get_value(:url, false)
+      @user = options.get_value(:user)
+      @pass = options.get_value(:pass)
+    end
+    
+    def execute(event)
+      con_url = URI.parse(@url)
+      req = Net::HTTP::Post.new(url.path)
+      if(@user && @pass)
+        req.basic_auth(@user, @pass)
+      end
+      req.set_form_data( {
+        'type' => 'watchdogger_event',
+        'event' => event.to_xml
+      }, ';'
+      )
+      res = Net::HTTP.new(url.host, url.port).start { |http| http.request(req) }
+      case res
+      when Net::HTTPSuccess, Net::HTTPRedirection:
+        dog_log.debug("HTPOST Action") { "Posted event to #{@url} "}
+      else
+        dog_log.warn("HTPOST Action") { "Could not post to #{@url}: #{@res}"}
+      end
+    rescue Exception => e
+      dog_log.warn("HTPOST Action") { "Error posting to #{@url}: #{e.message}"}
+    end
+    
+  end
+  
+end

data/lib/watcher_action/kill_process.rb

@@ -0,0 +1,24 @@
+module WatcherAction
+  
+  # Kills the process with the given PID.
+  # Options: 
+  #
+  #  pidfile    - The file containing the process id
+  #  signal     - The signal to send to the process. Defaults to KILL
+  class KillProcess
+    
+    def initialize(config)
+      @pidfile = config.get_value(:pidfile, false)
+      @signal= config.get_value(:signal, 'KILL')
+    end
+    
+    def execute(event)
+      pid = File.open(@pidfile) { |io| io.read }
+      Process.kill(@signal, pid.to_i)
+    rescue Exception => e
+      dog_log.warn { "Unable to kill process: #{e}" }
+    end
+    
+  end
+  
+end

data/lib/watcher_action/log_action.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+module WatcherAction
+  
+  # Logs the event information to the standard log file
+  # Options:
+  #
+  #  format - A format string that will receive the timestamp, watcher name and 
+  #           event message (in that order) as parameters (default message if not given)
+  #  severity - The severity of the log message (default: warn)
+  class LogAction
+    
+    def initialize(options)
+      @format = options.get_value(:format, "Watcher %s triggered at %s: %s")
+      if(severity = options.get_value(:severity))
+        @severity = Logger.const_get(severity.upcase)
+      else
+        @severity = Logger::WARN
+      end
+    end
+    
+    def execute(event)
+      dog_log.add(@severity, nil, 'LoggerAction') { @format % [event.watcher, event.timestamp, event.message] }
+    end
+    
+  end
+end

data/lib/watcher_action/send_mail.rb

@@ -0,0 +1,67 @@
+require 'rmail'
+require 'net/smtp'
+
+module WatcherAction
+  
+  # This action will send an email to a given receipient. It doesn't support any
+  # fancy features (you may want to do that handling externally) and will only
+  # use unencrypted smtp network connections.
+  # 
+  # Options for this action:
+  #
+  #   to             - Email address to which to send the message. May be a list. (required)
+  #   sender         - Email address of the person sending the mail (required)
+  #   subject        - Subject of the message. You can put %s for the event message. (defaults if not set)
+  #   body           - Body of the email message. If set to 'xml', it will include an
+  #                    XML representation of the event. If not set, it will default
+  #                    to a sensible description of the event. You can include the
+  #                    event's message as for the subject
+  #   server         - Address or name of the mail server to use (required)
+  #   port           - Port to connect to (default: 25)
+  #   user           - Mail server user name
+  #   pass           - Mail server password
+  #   authentication - Authentication method (default: plain)
+  class SendMail
+    
+    def initialize(config)
+      @mail_to = config.get_value(:to, false)
+      @sender = config.get_value(:sender, false)
+      @subject = config.get_value(:subject, "Watchdogger triggered: %s")
+      @body = config.get_value(:body)
+      @server = config.get_value(:server, false)
+      @port = config.get_value(:port, '25')
+      @user = config.get_value(:user)
+      @pass = config.get_value(:pass)
+      @authentication = config.get_value(:authentication, :plain).to_sym
+    end
+    
+    def execute(event)
+      msg = RMail::Message.new
+      msg.header.to = @mail_to
+      receipient = msg.header.to.split(',').first
+      msg.header.from = @sender
+      msg.header.subject = @subject % [event.message]
+      if(@body.to_s == 'xml')
+        msg.body = event.to_xml
+      elsif(@body)
+        msg.body = @body % [event.message]
+      else
+        msg.body = "The #{event.watcher.class.name} watcher of your watchdog triggered\nan event at #{event.timestamp}:\n#{event.message}"
+      end
+      
+      smtp_params = [@server, @port]
+      if(@user && @pass)
+        smtp_params << [nil, @user, @pass, @authentication]
+      end
+      
+      Net::SMTP.start(*smtp_params) do |smtp|
+        smtp.send_message(msg.to_str, msg.header.from, msg.header.to)
+      end
+      dog_log.debug('SMTP Action') { "Sent mail to #{@mail_to} through #{@server}" }
+    rescue Exception => e
+      dog_log.warn('SMTP Action') { "Could not send mail to #{@mail_to} on #{@server}: #{e.message}" }
+    end
+    
+  end
+
+end

data/lib/watcher_action.rb

@@ -0,0 +1,41 @@
+# Each action object contains the action that will be taken when a watched condition is triggered.
+#
+# Each action must respond to the #execute(event) method, which will execute the action.
+#
+# Actions should *not* log the executing to the log file, unless there is an unexpected error
+# in the execution of the action itself. If the user wants to log to the log file,
+# the logger action should be used. (All actions may use the log for debug-level information
+# in all places.)
+module WatcherAction
+  
+  class << self
+  
+    # creates a new action of the given type. The Action object itself will not
+    # be made public, instead call the #run_action method to execute it
+    def register(name, config_options)
+      assit_kind_of(String, name)
+      raise(ArgumentError, "Illegal options.") unless(config_options.is_a?(Hash))
+      type = config_options.get_value(:type, false)
+      type = WatchDogger.camelize(type)
+      registered_actions[name.to_sym] = WatcherAction.const_get(type).new(config_options)
+      dog_log.debug('Action Handler') { "Registered action '#{name}' of type #{type}"}
+    end
+    
+    # Runs the named action. Returns true if the action ran without exception.
+    def run_action(name, event)
+      registered_actions[name.to_sym].execute(event)
+      true
+    rescue Exception => e
+      dog_log.error('Action Handler') { "Could not execute #{name}: #{e.message} (Registered actions: #{registered_actions.keys.join(', ')})" }
+      false
+    end
+  
+    private
+    
+    def registered_actions
+      @registered_actions ||= {}
+    end
+  
+  end
+  
+end

data/lib/watcher_event.rb

@@ -0,0 +1,23 @@
+require 'builder'
+
+# Encodes the information of an event that was triggered.
+class WatcherEvent
+  
+  attr_accessor :timestamp
+  attr_accessor :watcher
+  attr_accessor :message
+  
+  def to_xml
+    builder = Builder::XmlMarkup.new()
+    builder.instruct!
+    builder.event do 
+      builder.timestamp(timestamp)
+      builder.message(message)
+      builder.watcher do
+        builder.name(watcher.name)
+        builder.watcher_type(watcher.class.name)
+      end
+    end
+  end
+    
+end

data/sample_config.yml

@@ -0,0 +1,16 @@
+# Watchdogger sample configuration
+
+actions:
+  log_it: 
+    type: log_action
+    
+watchers:
+  test_hn:
+    type: http_watcher
+    url: http://www.foobar.or/
+    actions: log_it
+    
+interval: 3
+logfile: daemon.log
+pidfile: watcher.pid
+    

data/test/http_watcher_test.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+# The URL that will be used for testing. Should return a 200 result and a body.
+TEST_URL = 'http://wiki.github.com/averell23/watchdogger'
+# Text that will be expected in the page body
+TEST_URL_TEXT = 'averell23'
+
+class HttpWatcherTest < Test::Unit::TestCase
+
+  def setup
+    @default_options = {
+      :url => TEST_URL, 
+      :actions => 'default', 
+      :timeout => '2'
+    }
+  end
+  
+  def test_simple
+    watcher = Watcher::HttpWatcher.new(@default_options)
+    assert_equal(false, watcher.watch_it!)
+  end
+
+  def test_simple_match
+    @default_options[:content_match] = TEST_URL_TEXT
+    watcher = Watcher::HttpWatcher.new(@default_options)
+    assert_equal(false, watcher.watch_it!)
+  end
+
+  def test_simple_response
+    @default_options[:response] = '200'
+    watcher = Watcher::HttpWatcher.new(@default_options)
+    assert_equal(false, watcher.watch_it!)
+  end
+
+  def test_404_response
+    @default_options[:url] = TEST_URL + '/narfnarf'
+    @default_options[:response] = '404'
+    watcher = Watcher::HttpWatcher.new(@default_options)
+    assert_equal(false, watcher.watch_it!)
+  end
+  
+  def test_404_response_fail
+    @default_options[:url] = TEST_URL + '/narfnarf'
+    watcher = Watcher::HttpWatcher.new(@default_options)
+    assert_kind_of(String, watcher.watch_it!)
+  end
+  
+  def test_simple_match_fail
+    @default_options[:content_match] = 'grubellnurf'
+    watcher = Watcher::HttpWatcher.new(@default_options)
+    assert_kind_of(String, watcher.watch_it!)
+  end
+  
+  def test_illegal_open_fail
+    watcher = Watcher::HttpWatcher.new(
+    :url => 'http://www.gurgl.gurl/', 
+    :actions => 'default',
+    :content_match => 'grubellnurf'
+    )
+    assert_kind_of(String, watcher.watch_it!)
+  end
+
+end

data/test/kill_process_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+PIDFILE = 'test.pid'
+
+class KillProcessTest < Test::Unit::TestCase
+  
+  def setup
+    @killer = WatcherAction::KillProcess.new(:pidfile => PIDFILE)
+    # Fork a dummy process that we can kill
+    @pid = Process.fork { loop { sleep 1 }}
+    @proc = Process.detach(@pid)
+    File.open(PIDFILE, 'w') { |io| io << @pid }
+  end
+  
+  def teardown
+    FileUtils.remove(PIDFILE) if(File.exists?(PIDFILE))
+    @proc.terminate! if(@proc.status != false)
+  rescue Exception => e
+    puts "! unclean teardown #{e}"
+  end
+  
+  def test_killer
+    assert_not_equal(false, @proc.status)
+    @killer.execute(WatcherEvent.new)
+    sleep 1 # Wait for the sleep - the ruby process will handle the kill only then
+    assert_equal(false, @proc.status)
+  end
+  
+end

data/test/log_watcher_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class LogWatcherTest < Test::Unit::TestCase
+  
+  def logfile
+    File.expand_path(File.join(File.dirname(__FILE__), 'log_test.tmp'))
+  end
+  
+  def setup
+    FileUtils.remove(logfile) if(File.exists?(logfile))
+    File.open(logfile, 'w') { |io| io << 'test' }
+    @watcher = Watcher::LogWatcher.new(
+      :logfile => logfile,
+      :match => 'da_test',
+      :interval_first => '1',
+      :interval_max => '1'
+    )
+  end
+  
+  def teardown
+    @watcher.cleanup
+    FileUtils.remove(logfile) if(File.exists?(logfile))
+  end
+  
+  def test_watcher_plain
+    assert_equal(false, @watcher.watch_it!)
+  end
+  
+  def test_watcher_trigger
+    File.open(logfile, 'a') do |io|
+      20.times { io << 'nothing special' }
+      io << 'da_test'
+    end
+    sleep 2
+    assert_kind_of(String, @watcher.watch_it!)
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'test/unit'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'watchdogger')
+
+DogLog.setup('tmp.log', Logger::DEBUG)

data/test/watchdogger_test.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Watcher
+  class DummyWatcher < Watcher::Base
+    def initialize(config)
+      @watchit = config[:watchit]
+    end
+    def watch_it!
+      @watchit
+    end
+    
+  end
+end
+
+module WatcherAction
+  class DummyAction
+    def initialize(config)
+    end
+    def execute(event)
+      @executed = true
+      raise(Exception) unless(event.is_a?(WatcherEvent))
+      raise(ArgumentError, "Boom!")
+    end
+  end
+end
+
+class WatchdoggerTest < Test::Unit::TestCase
+  
+  def setup
+    Watcher.instance_variable_set(:@registered_watchers, nil)
+    WatcherAction.instance_variable_set(:@registered_actions, nil)
+    WatcherAction.register('default', { :type => 'dummy_action' })
+    WatcherAction.register('log_action', { 'type' => :log_action })
+    Watcher.register('dummy', { :type => 'dummy_watcher', 'actions' => [ :default, :log_action ] })
+  end
+  
+  def test_create_watcher
+    watchers = Watcher.instance_variable_get(:@registered_watchers)
+    assert_equal(1, watchers.size)
+    assert_kind_of(Watcher::DummyWatcher, watchers.first)
+  end
+  
+  def test_watcher_actions
+    actions = Watcher.instance_variable_get(:@registered_watchers).first.send(:actions)
+    assert_equal([:default, :log_action], actions)
+  end
+  
+  def test_registered_action
+    actions = WatcherAction.instance_variable_get(:@registered_actions)
+    assert_equal(2, actions.size)
+    assert_kind_of(WatcherAction::DummyAction, actions[:default])
+    assert_kind_of(WatcherAction::LogAction, actions[:log_action])
+  end
+  
+  def test_run_action
+    event = WatcherEvent.new
+    event.timestamp = Time.now
+    event.message = "TEST MESSAGE"
+    event.watcher = "TEST"
+    assert_equal(false, WatcherAction.run_action('default', event))
+    assert_equal(true, action_status('default'))
+    WatcherAction.run_action('log_action', event)
+  end
+  
+  def test_run_watcher
+    assert_nothing_raised { Watcher.watch_all! }
+  end
+  
+  def test_run_watcher_execute
+    assert_equal(nil, action_status('default'))
+    Watcher.register('dummy2', { 'type' => :dummy_watcher, 'actions' => :default, :watchit => 'Fail' })
+    Watcher.watch_all!
+    assert_equal(true, action_status('default'))
+  end
+  
+  private
+  
+  def action_status(name)
+    action = WatcherAction.instance_variable_get(:@registered_actions).get_value(name)
+    action.instance_variable_get(:@executed)
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: averell23-watchdogger
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel Hahn
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-16 00:00:00 -07:00
+default_executable: watchdogger
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: file-tail
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: averell23-assit
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rmail
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.2
+    version: 
+description: A small flexible watchdog system to monitor servers.
+email: ghub@limitedcreativity.org
+executables: 
+- watchdogger
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGES
+- LICENSE
+- sample_config.yml
+files: 
+- lib/dog_log.rb
+- lib/watchdogger.rb
+- lib/watcher
+- lib/watcher/base.rb
+- lib/watcher/http_watcher.rb
+- lib/watcher/log_watcher.rb
+- lib/watcher.rb
+- lib/watcher_action
+- lib/watcher_action/htpost.rb
+- lib/watcher_action/kill_process.rb
+- lib/watcher_action/log_action.rb
+- lib/watcher_action/send_mail.rb
+- lib/watcher_action.rb
+- lib/watcher_event.rb
+- test/http_watcher_test.rb
+- test/kill_process_test.rb
+- test/log_watcher_test.rb
+- test/test_helper.rb
+- test/watchdogger_test.rb
+- bin/watchdogger
+- README.rdoc
+- CHANGES
+- LICENSE
+- sample_config.yml
+has_rdoc: true
+homepage: http://averell23.github.com/watchdogger
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple and flexible watchdog running on Ruby.
+test_files: []
+