averell23-watchdogger 0.1.5 → 0.2.0

data/lib/watchdogger.rb

@@ -105,17 +105,23 @@ module WatchDogger # :nodoc:
     # daemon is still running.
     def check_daemon
       return false unless(File.exists?(@pidfile))
-      pid = get_pid
+      check_process(get_pid)
+    end
+    
+    # Returns true if the system thinks that the given process is still alive
+    def check_process(pid)
       begin
         Process.kill(0, pid)
+        dog_log.debug('Watchdogger') { "Process #{pid} is alive" }
         true
       rescue Errno::EPERM
+        dog_log.debug('Watchdogger') { "No permissions for process #{pid} - seems to be running."}
         true
       rescue Errno::ESRCH
-        dog_log.info('Watchdogger') { "Old process #{pid} is stale, good to go." }
+        dog_log.debug('Watchdogger') { "Found stale process for #{pid}." }
         false
       rescue Exception => e
-        dog_log.error('Watchdogger') { "Could not find out if process #{pid} still runs (#{e.message}). Hoping for the best..." }
+        dog_log.info('Watchdogger') { "Could not find out if process #{pid} still runs (#{e.message}). Hoping for the best..." }
         false
       end
     end
@@ -174,4 +180,16 @@ class Hash # :nodoc:
     value
   end
   
+  # Gets the given key as an array. If it's already an array, it will be returned,
+  # otherwise we'll check if it's a comma-separated list. The
+  # default will be processed in the same way as if was read from the Hash.
+  def get_list(sym_or_string, default = nil)
+    value = get_value(sym_or_string, default)
+    return value if(value.is_a?(Array))
+    assit(value.is_a?(String) || value.is_a?(Symbol))
+    value = value.to_s.split(',').collect do |val|
+      val.strip 
+    end
+  end
+  
 end

data/lib/watcher/base.rb

@@ -36,21 +36,10 @@ module Watcher
 
      # Sets up all actions for this watcher
      def setup_actions(configuration)
-       action_config = configuration.get_value(:actions)
-       raise(ArgumentError, "No actions passed to watcher.") unless(action_config)
-       if(action_config.is_a?(Array))
-         action_config.each { |ac| add_action_to(actions, ac) }
-       else
-         assit(action_config.is_a?(String) || action_config.is_a?(Symbol))
-         add_action_to(actions, action_config)
-       end
-       warn_config = configuration.get_value(:warn_actions)
-       if(warn_config.is_a?(Array))
-         warn_config.each { |ac| add_action_to(warn_actions, ac) }
-       elsif(warn_config)
-         assit_kind_of(String, warn_config)
-         add_action_to(warn_actions, warn_config)
-       end
+       action_config = configuration.get_list(:actions, false)
+       action_config.each { |ac| add_action_to(actions, ac) }
+       warn_config = configuration.get_list(:warn_actions, [])
+       warn_config.each { |ac| add_action_to(warn_actions, ac) }
      end
 
      private

data/lib/watcher/http_watcher.rb

@@ -11,12 +11,16 @@ module Watcher
   # [*content_match*] A regular expression that is matched against the result.
   #                   The watcher fails if the expression doesn't match
   # [*timeout*] The timeout for the connection attempt. Defaults to 10 sec
-  # 
+  # [*falloff*] If a successful connection is made, this is subtracted from
+  #             the internal severity. (Default: 100, completely reset previous
+  #             failures)
+  #
   # If neither response nor content_match are given, the watcher will expect a 
   # 200 OK response from the server.
   #
   # This watcher resets the current severity on each successful connect, so that
-  # only continuous failures count against the trigger condition.
+  # only continuous failures count against the trigger condition - see the falloff
+  # option.
   class HttpWatcher < Watcher::Base
     
     def initialize(config)
@@ -26,6 +30,8 @@ module Watcher
       response = config.get_value(:response)
       @response = ((!response && !match) ? "200" : response)
       @timeout = config.get_value(:timeout, 10).to_i
+      @falloff = config.get_value(:falloff, 100).to_i
+      @current_severity = 0
     end
     
     def watch_it!
@@ -40,7 +46,7 @@ module Watcher
       elsif(@content_match && !@content_match.match(res.body))
         test_failed = "Did not find #{@content_match.to_s} at #{@url}"
       end
-      @current_severity = 0 unless(test_failed)
+      @current_severity = [0, @current_severity - @falloff].min unless(test_failed)
       dog_log.debug('HttpWatcher') { "Watch of #{@url} resulted in #{test_failed}" }
       test_failed
     rescue Exception => e

data/lib/watcher/log_watcher.rb

@@ -82,6 +82,7 @@ module Watcher
           :reopen_suspicious => true,
           :suspicious_interval => (@interval_max * 3)
         )
+        dog_log.info('Logger Thread') { "Log watcher thread started" }
         logfile.tail do |line|
           if(matcher.match(line))
             triggered!

data/lib/watcher_action.rb

@@ -34,6 +34,11 @@ module WatcherAction
     def has_action?(name)
       registered_actions[name.to_sym] != nil
     end
+    
+    # Checks if the given action is registered with that name
+    def is_action?(name, action)
+      registered_actions[name.to_sym] == action
+    end
   
     private
     

data/lib/watcher_action/kill_process.rb

@@ -5,17 +5,34 @@ module WatcherAction
   # =Options
   #
   # [*pidfile*] The file containing the process id
-  # [*signal*] The signal to send to the process. Defaults to KILL
+  # [*signal*] The signal to send to the process. 
+  #            This may be an array or a comma-separated
+  #            list of signals. If there is more than one signal, this
+  #            will wait for _wait_ seconds before trying the next
+  #            signal, if the process didn't die.
+  #            Defaults to KILL
+  # [*wait*] Time to wait between signals (Default: 5)
   class KillProcess
     
     def initialize(config)
       @pidfile = config.get_value(:pidfile, false)
-      @signal= config.get_value(:signal, 'KILL')
+      @signals = config.get_list(:signal, 'KILL')
+      @wait = config.get_value(:wait, 5).to_i
     end
     
     def execute(event)
-      pid = File.open(@pidfile) { |io| io.read }
-      Process.kill(@signal, pid.to_i)
+      Thread.new(@signals, @wait, @pidfile) do |signals, wait, pidfile|
+        pid = File.open(pidfile) { |io| io.read }.to_i
+        signals.each_with_index do |signal, index|
+          sleep(wait) if(index > 0)
+          if(WatchDogger.check_process(pid))
+            dog_log.debug('KillerThread') { "Sending signal #{signal} to process #{pid}" }
+            Process.kill(signal, pid)
+          else
+            dog_log.debug('KillerThread') { "Process #{pid} is dead." }
+          end
+        end
+      end
     rescue Exception => e
       dog_log.warn { "Unable to kill process: #{e}" }
     end

data/lib/watcher_action/meta_action.rb

@@ -10,18 +10,20 @@ module WatcherAction
   class MetaAction
     
     def initialize(config)
-      actions = config.get_value(:actions, false)
-      if(actions.is_a?(Array))
-        @actions = actions
-      else
-        @actions = [ actions ]
-      end
+      actions = config.get_list(:actions, false)
+      actions.each { |ac| add_action(ac) }
     end
     
     def execute(event)
       @actions.each { |ac| WatcherAction.run_action(ac, event) }
     end
     
+    def add_action(action)
+      @actions ||= []
+      raise(ArgumentError, "Trying to add myself, creating a loop.") if(WatcherAction.is_action?(action, self))
+      @actions << action
+    end
+    
   end
   
 end

data/lib/watcher_action/send_mail.rb

@@ -1,11 +1,12 @@
 require 'rmail'
+require 'tlsmail' if(/^1.8/ =~ RUBY_VERSION) # Include the hack for ruby 1.8
 require 'net/smtp'
+require 'time'
 
 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.
+  # fancy features (you may want to do that handling externally).
   # 
   # =Options
   #
@@ -21,18 +22,20 @@ module WatcherAction
   # [*user*] Mail server user name
   # [*pass*] Mail server password
   # [*authentication*] Authentication method (default: plain)
+  # [*enable_tls*] Use the TLS encryption (default: false)
   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")
+      @subject = config.get_value(:subject, "Watchdogger needs your attention.")
       @body = config.get_value(:body)
       @server = config.get_value(:server, 'localhost')
       @port = config.get_value(:port, '25')
       @user = config.get_value(:user)
       @pass = config.get_value(:pass)
       @authentication = config.get_value(:authentication, :plain).to_sym
+      @enable_tls = config.get_value(:enable_tls) || false
     end
     
     def execute(event)
@@ -40,7 +43,8 @@ module WatcherAction
       msg.header.to = @mail_to
       receipient = msg.header.to.to_s.split(',').first
       msg.header.from = @sender
-      msg.header.subject = @subject % [event.message]
+      msg.header.subject =  @subject % [event.message]
+      msg.header.date = Time.now
       if(@body.to_s == 'xml')
         msg.body = event.to_xml
       elsif(@body)
@@ -48,18 +52,25 @@ module WatcherAction
       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]
+        smtp_params.concat([nil, @user, @pass, @authentication])
       end
       
-      Net::SMTP.start(*smtp_params) do |smtp|
-        smtp.send_message(msg.to_str, msg.header.from, msg.header.to)
+      Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE) if(@enable_tls)
+      Thread.new(smtp_params, msg, @sender, @mail_to) do |params, msg, sender, mail_to|
+          begin
+          Net::SMTP.start(*params) do |smtp|
+            smtp.send_message(msg.to_s, sender, mail_to)
+          end
+          dog_log.debug('SMTP Thread') { "Sent mail to #{mail_to} through #{params.first}" }
+        rescue Exception => e
+          dog_log.error('SMTP Thread') { "Could not send mail to #{mail_to} on #{params.first}: #{e.message}" }
+        end
       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}" }
+      dog_log.error('SMTP Action') { "Could not send mail to #{@mail_to} on #{@server}: #{e.message}" }
     end
     
   end

data/sample_config.yml

@@ -3,6 +3,16 @@
 actions:
   log_it: 
     type: log_action
+  mail_message:
+    type: send_mail
+    to: one@gmail.com
+    sender: myself@gmail.com
+    server: smtp.gmail.com
+    user: test@gmail.com
+    pass: secret
+    port: 587
+    authentication: login
+    enable_tls: true
     
 watchers:
   test_hn:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: averell23-watchdogger
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors: 
 - Daniel Hahn
@@ -62,6 +62,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.6.5
     version: 
+- !ruby/object:Gem::Dependency 
+  name: tlsmail
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.1
+    version: 
 description: A small flexible watchdog system to monitor servers.
 email: ghub@limitedcreativity.org
 executables: