god 0.5.0 → 0.6.0

data/lib/god/cli/run.rb

@@ -0,0 +1,120 @@
+module God
+  module CLI
+    
+    class Run
+      def initialize(options)
+        @options = options
+        
+        dispatch
+      end
+      
+      def dispatch
+        # have at_exit start god
+        $run = true
+        
+        if @options[:daemonize]
+          run_daemonized
+        else
+          run_in_front
+        end
+      end
+      
+      def run_daemonized
+        # trap and ignore SIGHUP
+        Signal.trap('HUP') {}
+        
+        pid = fork do
+          begin
+            require 'god'
+            
+            log_file = @options[:log] || "/dev/null"
+            
+            unless God::EventHandler.loaded?
+              puts
+              puts "***********************************************************************"
+              puts "*"
+              puts "* Event conditions are not available for your installation of god."
+              puts "* You may still use and write custom conditions using the poll system"
+              puts "*"
+              puts "***********************************************************************"
+              puts
+            end
+            
+            # set port if requested
+            if @options[:port]
+              God.port = @options[:port]
+            end
+            
+            # set pid if requested
+            if @options[:pid]
+              God.pid = @options[:pid] 
+            end
+            
+            # load config
+            if @options[:config]
+              unless File.exist?(@options[:config])
+                abort "File not found: #{@options[:config]}"
+              end
+              
+              begin
+                load File.expand_path(@options[:config])
+              rescue Exception => e
+                if e.instance_of?(SystemExit)
+                  raise
+                else
+                  puts e.message
+                  puts e.backtrace.join("\n")
+                  abort "There was an error in your configuration file (see above)"
+                end
+              end
+            end
+            
+            # reset file descriptors
+            STDIN.reopen "/dev/null"
+            STDOUT.reopen(log_file, "a")
+            STDERR.reopen STDOUT
+          rescue => e
+            puts e.message
+            puts e.backtrace.join("\n")
+            abort "There was a fatal system error while starting god (see above)"
+          end
+        end
+        
+        if @options[:pid]
+          File.open(@options[:pid], 'w') { |f| f.write pid }
+        end
+        
+        ::Process.detach pid
+        
+        exit
+      end
+      
+      def run_in_front
+        require 'god'
+        
+        if @options[:port]
+          God.port = @options[:port]
+        end
+        
+        if @options[:config]
+          unless File.exist?(@options[:config])
+            abort "File not found: #{@options[:config]}"
+          end
+          
+          begin
+            load File.expand_path(@options[:config])
+          rescue Exception => e
+            if e.instance_of?(SystemExit)
+              raise
+            else
+              puts e.message
+              puts e.backtrace.join("\n")
+              abort "There was an error in your configuration file (see above)"
+            end
+          end
+        end
+      end
+    end # Run
+    
+  end
+end

data/lib/god/cli/version.rb

@@ -0,0 +1,23 @@
+module God
+  module CLI
+    
+    class Version
+      def self.version
+        require 'god'
+    
+        # print version
+        puts "Version #{God::VERSION}"
+        exit
+      end
+      
+      def self.version_extended
+        puts "Version: #{God::VERSION}"
+        puts "Polls: enabled"
+        puts "Events: " + God::EventHandler.event_system
+    
+        exit
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/complex.rb

@@ -0,0 +1,86 @@
+module God
+  module Conditions
+    
+    class Complex < PollCondition
+      AND = 0x1 
+      OR  = 0x2
+      NOT = 0x4
+        
+      def initialize()
+        super
+        
+        @oper_stack = []
+        @op_stack = []
+        
+        @this = nil
+      end
+      
+      def valid?
+        @oper_stack.inject(true) { |acc, oper| acc & oper.valid? }
+      end
+      
+      def prepare
+        @oper_stack.each { |oper| oper.prepare }
+      end
+      
+      def new_oper(kind, op)
+        oper = Condition.generate(kind, self.watch)
+        @oper_stack.push(oper)
+        @op_stack.push(op)
+        oper
+      end
+      
+      def this(kind)
+        @this = Condition.generate(kind, self.watch)
+        yield @this if block_given?
+      end
+      
+      def and(kind)
+        oper = new_oper(kind, 0x1)
+        yield oper if block_given?
+      end
+      
+      def and_not(kind)
+        oper = new_oper(kind, 0x5)
+        yield oper if block_given?
+      end
+      
+      def or(kind)
+        oper = new_oper(kind, 0x2)
+        yield oper if block_given?
+      end
+      
+      def or_not(kind)
+        oper = new_oper(kind, 0x6)
+        yield oper if block_given?
+      end
+      
+      def test
+        if @this.nil?
+          # Although this() makes sense semantically and therefore
+          # encourages easy-to-read conditions, being able to omit it
+          # allows for more DRY code in some cases, so we deal with a
+          # nil @this here by initially setting res to true or false,
+          # depending on whether the first operator used is AND or OR
+          # respectively.
+          if 0 < @op_stack[0] & AND
+            res = true
+          else
+            res = false
+          end
+        else
+          res = @this.test
+        end
+        
+        @op_stack.each do |op|
+          cond = @oper_stack.shift
+          eval "res " + ((0 < op & AND) ? "&&" : "||") + "= " + ((0 < op & NOT) ? "!" : "") + "cond.test"
+          @oper_stack.push cond
+        end
+        
+        res
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/cpu_usage.rb

@@ -1,6 +1,33 @@
 module God
   module Conditions
     
+    # Condition Symbol :cpu_usage
+    # Type: Poll
+    # 
+    # Trigger when the percent of CPU use of a process is above a specified limit.
+    # On multi-core systems, this number could conceivably be above 100.
+    #
+    # Paramaters
+    #   Required
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #     +above+ is the percent CPU above which to trigger the condition. You 
+    #             may use #percent to clarify this amount (see examples).
+    #
+    # Examples
+    #
+    # Trigger if the process is using more than 25 percent of the cpu (from a Watch):
+    #
+    #   on.condition(:cpu_usage) do |c|
+    #     c.above = 25.percent
+    #   end
+    #
+    # Non-Watch Tasks must specify a PID file:
+    #
+    #   on.condition(:cpu_usage) do |c|
+    #     c.above = 25.percent
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
     class CpuUsage < PollCondition
       attr_accessor :above, :times
     

data/lib/god/conditions/disk_usage.rb

@@ -0,0 +1,27 @@
+module God
+  module Conditions
+    
+    class DiskUsage < PollCondition
+      attr_accessor :above, :mount_point
+      
+      def initialize
+        super
+        self.above = nil
+        self.mount_point = nil
+      end
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'mount_point' must be specified", self) if self.mount_point.nil?
+        valid &= complain("Attribute 'above' must be specified", self) if self.above.nil?
+        valid
+      end
+      
+      def test
+        usage = `df | grep -i " #{self.mount_point}$" | awk '{print $5}' | sed 's/%//'`
+        usage.to_i > self.above
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/flapping.rb

@@ -1,8 +1,42 @@
 module God
   module Conditions
     
+    # Condition Symbol :flapping
+    # Type: Trigger
+    # 
+    # Trigger when a Task transitions to or from a state or states a given number
+    # of times within a given period. 
+    #
+    # Paramaters
+    #   Required
+    #     +times+ is the number of times that the Task must transition before
+    #             triggering.
+    #     +within+ is the number of seconds within which the Task must transition
+    #              the specified number of times before triggering. You may use
+    #              the sugar methods #seconds, #minutes, #hours, #days to clarify
+    #              your code (see examples).
+    #     --one or both of--
+    #     +from_state+ is the state (as a Symbol) from which the transition must occur.
+    #     +to_state is the state (as a Symbol) to which the transition must occur.
+    #
+    #   Optional:
+    #     +retry_in+ is the number of seconds after which to re-monitor the Task after
+    #                it has been disabled by the condition.
+    #     +retry_times+ is the number of times after which to permanently unmonitor
+    #                   the Task.
+    #     +retry_within+ is the number of seconds within which 
+    #
+    # Examples
+    #
+    # Trigger if
     class Flapping < TriggerCondition
-      attr_accessor :times, :within, :from_state, :to_state, :retry_in, :retry_times, :retry_within
+      attr_accessor :times,
+                    :within,
+                    :from_state,
+                    :to_state,
+                    :retry_in,
+                    :retry_times,
+                    :retry_within
       
       def initialize
         self.info = "process is flapping"
@@ -64,26 +98,23 @@ module God
               
               # log
               msg = "#{self.watch.name} giving up"
-              Syslog.debug(msg)
-              LOG.log(self.watch, :info, msg)
+              applog(self.watch, :info, msg)
             end
           else
             # try again later
             Thread.new do
               sleep 1
-            
+              
               # log
               msg = "#{self.watch.name} auto-reenable monitoring in #{self.retry_in} seconds"
-              Syslog.debug(msg)
-              LOG.log(self.watch, :info, msg)
-            
+              applog(self.watch, :info, msg)
+              
               sleep self.retry_in
-            
+              
               # log
               msg = "#{self.watch.name} auto-reenabling monitoring"
-              Syslog.debug(msg)
-              LOG.log(self.watch, :info, msg)
-            
+              applog(self.watch, :info, msg)
+              
               if self.watch.state == :unmonitored
                 self.watch.monitor
               end

data/lib/god/conditions/http_response_code.rb

@@ -3,6 +3,64 @@ require 'net/http'
 module God
   module Conditions
     
+    # Condition Symbol :http_response_code
+    # Type: Poll
+    # 
+    # Trigger based on the response from an HTTP request.
+    #
+    # Paramaters
+    #   Required
+    #     +host+ is the hostname to connect [required]
+    #     --one of code_is or code_is_not--
+    #     +code_is+ trigger if the response code IS one of these
+    #               e.g. 500 or '500' or [404, 500] or %w{404 500}
+    #     +code_is_not+ trigger if the response code IS NOT one of these
+    #                   e.g. 200 or '200' or [200, 302] or %w{200 302}
+    #  Optional
+    #     +port+ is the port to connect (default 80)
+    #     +path+ is the path to connect (default '/')
+    #     +times+ is the number of times after which to trigger (default 1)
+    #             e.g. 3 (times in a row) or [3, 5] (three out of fives times)
+    #     +timeout+ is the time to wait for a connection (default 60.seconds)
+    #
+    # Examples
+    #
+    # Trigger if the response code from www.example.com/foo/bar
+    # is not a 200 (or if the connection is refused or times out:
+    #
+    #   on.condition(:http_response_code) do |c|
+    #     c.host = 'www.example.com'
+    #     c.path = '/foo/bar'
+    #     c.code_is_not = 200
+    #   end
+    #
+    # Trigger if the response code is a 404 or a 500 (will not
+    # be triggered by a connection refusal or timeout):
+    #
+    #   on.condition(:http_response_code) do |c|
+    #     c.host = 'www.example.com'
+    #     c.path = '/foo/bar'
+    #     c.code_is = [404, 500]
+    #   end
+    #
+    # Trigger if the response code is not a 200 five times in a row:
+    #
+    #   on.condition(:http_response_code) do |c|
+    #     c.host = 'www.example.com'
+    #     c.path = '/foo/bar'
+    #     c.code_is_not = 200
+    #     c.times = 5
+    #   end
+    #
+    # Trigger if the response code is not a 200 or does not respond
+    # within 10 seconds:
+    #
+    #   on.condition(:http_response_code) do |c|
+    #     c.host = 'www.example.com'
+    #     c.path = '/foo/bar'
+    #     c.code_is_not = 200
+    #     c.timeout = 10
+    #   end
     class HttpResponseCode < PollCondition
       attr_accessor :code_is,      # e.g. 500 or '500' or [404, 500] or %w{404 500}
                     :code_is_not,  # e.g. 200 or '200' or [200, 302] or %w{200 302}
@@ -14,7 +72,10 @@ module God
       
       def initialize
         super
+        self.port = 80
+        self.path = '/'
         self.times = [1, 1]
+        self.timeout = 60.seconds
       end
       
       def prepare
@@ -37,11 +98,8 @@ module God
       def valid?
         valid = true
         valid &= complain("Attribute 'host' must be specified", self) if self.host.nil?
-        valid &= complain("Attribute 'port' must be specified", self) if self.port.nil?
-        valid &= complain("Attribute 'path' must be specified", self) if self.path.nil?
         valid &= complain("One (and only one) of attributes 'code_is' and 'code_is_not' must be specified", self) if
           (self.code_is.nil? && self.code_is_not.nil?) || (self.code_is && self.code_is_not)
-        valid &= complain("Attribute 'timeout' must be specified", self) if self.timeout.nil?
         valid
       end
       
@@ -61,6 +119,8 @@ module God
         else
           fail(actual_response_code)
         end
+      rescue Errno::ECONNREFUSED
+        self.code_is ? fail('Refused') : pass('Refused')
       rescue Timeout::Error
         self.code_is ? fail('Timeout') : pass('Timeout')
       end