god 0.6.0 → 0.7.0

data/lib/god/condition.rb

@@ -1,7 +1,7 @@
 module God
   
   class Condition < Behavior
-    attr_accessor :transition, :notify, :info
+    attr_accessor :transition, :notify, :info, :phase
     
     # Generate a Condition of the given kind. The proper class if found by camel casing the
     # kind (which is given as an underscored symbol).
@@ -14,6 +14,10 @@ module God
         abort "Condition '#{c.class.name}' must subclass God::PollCondition, God::EventCondition, or God::TriggerCondition" 
       end
       
+      if !EventHandler.loaded? && c.kind_of?(EventCondition)
+        abort "Condition '#{c.class.name}' requires an event system but none has been loaded"
+      end
+      
       c.watch = watch
       c
     rescue NameError
@@ -77,7 +81,7 @@ module God
     end
     
     def trigger
-      Hub.trigger(self)
+      self.watch.trigger(self)
     end
     
     def register

data/lib/god/conditions/cpu_usage.rb

@@ -29,7 +29,7 @@ module God
     #     c.pid_file = "/var/run/mongrel.3000.pid"
     #   end
     class CpuUsage < PollCondition
-      attr_accessor :above, :times
+      attr_accessor :above, :times, :pid_file
     
       def initialize
         super
@@ -49,18 +49,19 @@ module God
         @timeline.clear
       end
       
+      def pid
+        self.watch.pid || File.read(self.pid_file).strip.to_i
+      end
+      
       def valid?
         valid = true
-        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil? && self.pid_file.nil?
         valid &= complain("Attribute 'above' must be specified", self) if self.above.nil?
         valid
       end
       
       def test
-        return false unless File.exist?(self.watch.pid_file)
-        
-        pid = File.read(self.watch.pid_file).strip
-        process = System::Process.new(pid)
+        process = System::Process.new(self.pid)
         @timeline.push(process.percent_cpu)
         
         history = "[" + @timeline.map { |x| "#{x > self.above ? '*' : ''}#{x}%%" }.join(", ") + "]"

data/lib/god/conditions/http_response_code.rb

@@ -108,7 +108,7 @@ module God
         
         Net::HTTP.start(self.host, self.port) do |http|
           http.read_timeout = self.timeout
-          response = http.head(self.path)
+          response = http.get(self.path)
         end
         
         actual_response_code = response.code.to_i
@@ -121,6 +121,10 @@ module God
         end
       rescue Errno::ECONNREFUSED
         self.code_is ? fail('Refused') : pass('Refused')
+      rescue Errno::ECONNRESET
+        self.code_is ? fail('Reset') : pass('Reset')
+      rescue EOFError
+        self.code_is ? fail('EOF') : pass('EOF')
       rescue Timeout::Error
         self.code_is ? fail('Timeout') : pass('Timeout')
       end

data/lib/god/conditions/memory_usage.rb

@@ -31,7 +31,7 @@ module God
     #     c.pid_file = "/var/run/mongrel.3000.pid"
     #   end
     class MemoryUsage < PollCondition
-      attr_accessor :above, :times
+      attr_accessor :above, :times, :pid_file
       
       def initialize
         super
@@ -51,18 +51,19 @@ module God
         @timeline.clear
       end
       
+      def pid
+        self.watch.pid || File.read(self.pid_file).strip.to_i
+      end
+      
       def valid?
         valid = true
-        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil? && self.pid_file.nil?
         valid &= complain("Attribute 'above' must be specified", self) if self.above.nil?
         valid
       end
       
       def test
-        return false unless File.exist?(self.watch.pid_file)
-        
-        pid = File.read(self.watch.pid_file).strip
-        process = System::Process.new(pid)
+        process = System::Process.new(self.pid)
         @timeline.push(process.memory)
         
         history = "[" + @timeline.map { |x| "#{x > self.above ? '*' : ''}#{x}kb" }.join(", ") + "]"

data/lib/god/conditions/process_exits.rb

@@ -28,30 +28,35 @@ module God
       end
       
       def valid?
-        valid = true
-        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
-        valid
+        true
       end
-    
+      
       def register
-        pid = File.read(self.watch.pid_file).strip.to_i
+        pid = self.watch.pid
         
         begin
           EventHandler.register(pid, :proc_exit) do |extra|
-            self.info = "process exited #{extra.inspect}"
-            Hub.trigger(self)
+            formatted_extra = extra.size > 0 ? " #{extra.inspect}" : ""
+            self.info = "process #{pid} exited#{formatted_extra}"
+            self.watch.trigger(self)
           end
+          
+          msg = "#{self.watch.name} registered 'proc_exit' event for pid #{pid}"
+          applog(self.watch, :info, msg)
         rescue StandardError
           raise EventRegistrationFailedError.new
         end
       end
       
       def deregister
-        if File.exist?(self.watch.pid_file)
-          pid = File.read(self.watch.pid_file).strip.to_i
+        pid = self.watch.pid
+        if pid
           EventHandler.deregister(pid, :proc_exit)
+          
+          msg = "#{self.watch.name} deregistered 'proc_exit' event for pid #{pid}"
+          applog(self.watch, :info, msg)
         else
-          applog(self.watch, :error, "#{self.watch.name} could not deregister: no such PID file #{self.watch.pid_file} (#{self.base_name})")
+          applog(self.watch, :error, "#{self.watch.name} could not deregister: no cached PID or PID file #{self.watch.pid_file} (#{self.base_name})")
         end
       end
     end

data/lib/god/conditions/process_running.rb

@@ -34,37 +34,41 @@ module God
     #     c.pid_file = "/var/run/mongrel.3000.pid"
     #   end
     class ProcessRunning < PollCondition
-      attr_accessor :running
+      attr_accessor :running, :pid_file
+      
+      def pid
+        self.watch.pid || File.read(self.pid_file).strip.to_i
+      end
       
       def valid?
         valid = true
-        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil? && self.pid_file.nil?
         valid &= complain("Attribute 'running' must be specified", self) if self.running.nil?
         valid
       end
-    
+      
       def test
         self.info = []
         
-        unless File.exist?(self.watch.pid_file)
-          self.info << "#{self.watch.name} #{self.class.name}: no such pid file: #{self.watch.pid_file}"
-          return !self.running
-        end
+        # unless File.exist?(self.watch.pid_file)
+        #   self.info << "#{self.watch.name} #{self.class.name}: no such pid file: #{self.watch.pid_file}"
+        #   return !self.running
+        # end
         
-        pid = File.read(self.watch.pid_file).strip
-        active = System::Process.new(pid).exists?
+        pid = self.watch.pid
+        active = pid && System::Process.new(pid).exists?
         
         if (self.running && active)
-          self.info << "process is running"
+          self.info.concat(["process is running"])
           true
         elsif (!self.running && !active)
-          self.info << "process is not running"
+          self.info.concat(["process is not running"])
           true
         else
           if self.running
-            self.info << "process is not running"
+            self.info.concat(["process is not running"])
           else
-            self.info << "process is running"
+            self.info.concat(["process is running"])
           end
           false
         end

data/lib/god/diagnostics.rb

@@ -0,0 +1,37 @@
+def start_dike
+  require 'dike'
+  Thread.new do
+    Dike.logfactory File.join(File.dirname(__FILE__), *%w[.. .. logs])
+    loop do
+      Dike.finger
+      sleep(1)
+    end
+  end
+end
+
+class BleakHouseDiagnostic
+  LOG_FILE = File.join(File.dirname(__FILE__), *%w[.. .. logs bleak.log])
+  
+  class << self
+    attr_accessor :logger
+  end
+  
+  def self.install
+    require 'bleak_house'
+    self.logger = BleakHouse::Logger.new
+    File.delete(LOG_FILE) rescue nil
+  end
+  
+  def self.snapshot
+    self.logger.snapshot(LOG_FILE, "timer", false) if self.logger
+  end
+  
+  def self.spin(delay = 1)
+    Thread.new do
+      loop do
+        self.snapshot
+        sleep(delay)
+      end
+    end
+  end
+end

data/lib/god/driver.rb

@@ -0,0 +1,108 @@
+module God
+  
+  class DriverEvent
+    attr_accessor :condition, :at
+    
+    # Instantiate a new TimerEvent that will be triggered after the specified delay
+    #   +condition+ is the Condition
+    #   +delay+ is the number of seconds from now at which to trigger
+    #
+    # Returns TimerEvent
+    def initialize(condition, delay)
+      self.condition = condition
+      self.at = Time.now + delay
+    end
+    
+    def due?
+      Time.now >= self.at
+    end
+  end # DriverEvent
+  
+  class Driver
+    attr_reader :thread
+    
+    INTERVAL = 0.25
+    
+    # Instantiate a new Driver and start the scheduler loop to handle events
+    #   +task+ is the Task this Driver belongs to
+    #
+    # Returns Driver
+    def initialize(task)
+      @task = task
+      @events = []
+      @ops = Queue.new
+      
+      @thread = Thread.new do
+        loop do
+          begin
+            if !@ops.empty?
+              self.handle_op
+            elsif !@events.empty?
+              self.handle_event
+            else
+              sleep INTERVAL
+            end
+          rescue Exception => e
+            message = format("Unhandled exception in driver loop - (%s): %s\n%s",
+                             e.class, e.message, e.backtrace.join("\n"))
+            applog(nil, :fatal, message)
+          end
+        end
+      end
+    end
+    
+    # Handle the next queued operation that was issued asynchronously
+    #
+    # Returns nothing
+    def handle_op
+      command = @ops.pop
+      @task.send(command[0], *command[1])
+    end
+    
+    # Handle the next event (poll condition) that is due
+    #
+    # Returns nothing
+    def handle_event
+      if @events.first.due?
+        event = @events.shift
+        @task.handle_poll(event.condition)
+      end
+      
+      # don't sleep if there is a pending event and it is due
+      unless @events.first && @events.first.due?
+        sleep INTERVAL
+      end
+    end
+    
+    # Clear all events for this Driver
+    #
+    # Returns nothing
+    def clear_events
+      @events.clear
+    end
+    
+    # Queue an asynchronous message
+    #   +name+ is the Symbol name of the operation
+    #   +args+ is an optional Array of arguments
+    #
+    # Returns nothing
+    def message(name, args = [])
+      @ops.push([name, args])
+    end
+    
+    # Create and schedule a new DriverEvent
+    #   +condition+ is the Condition
+    #   +delay+ is the number of seconds to delay (default: interval defined in condition)
+    #
+    # Returns nothing
+    def schedule(condition, delay = condition.interval)
+      applog(nil, :debug, "driver schedule #{condition} in #{delay} seconds")
+      
+      @events.concat([DriverEvent.new(condition, delay)])
+      
+      # sort events
+      @events.sort! { |x, y| x.at <=> y.at }
+    end
+  end # Driver
+  
+end # God

data/lib/god/event_handler.rb

@@ -61,9 +61,49 @@ module God
     def self.start
       Thread.new do
         loop do
-          @@handler.handle_events
+          begin
+            @@handler.handle_events
+          rescue Exception => e
+            message = format("Unhandled exception (%s): %s\n%s",
+                             e.class, e.message, e.backtrace.join("\n"))
+            applog(nil, :fatal, message)
+          end
         end
       end
+      
+      # do a real test to make sure events are working properly
+      @@loaded = self.operational?
+    end
+    
+    def self.operational?
+      com = [false]
+      
+      Thread.new do
+        begin
+          event_system = God::EventHandler.event_system
+          
+          pid = fork do
+            loop { sleep(1) }
+          end
+          
+          self.register(pid, :proc_exit) do
+            com[0] = true
+          end
+          
+          ::Process.kill('KILL', pid)
+          
+          sleep(0.1)
+          
+          self.deregister(pid, :proc_exit) rescue nil
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+        end
+      end.join
+      
+      sleep(0.1)
+      
+      com.first
     end
     
   end

data/lib/god/logger.rb

@@ -9,49 +9,76 @@ module God
     
     attr_accessor :logs
     
+    class << self
+      attr_accessor :syslog
+    end
+    
+    self.syslog ||= true
+    
+    # Instantiate a new Logger object
     def initialize
       super($stdout)
       self.logs = {}
       @mutex = Mutex.new
       @capture = nil
+      @templogio = StringIO.new
+      @templog = ::Logger.new(@templogio)
+      @templog.level = Logger::INFO
+      load_syslog
     end
     
-    def start_capture
-      @mutex.synchronize do
-        @capture = StringIO.new
-      end
-    end
-    
-    def finish_capture
-      @mutex.synchronize do
-        cap = @capture.string
-        @capture = nil
-        cap
+    # If Logger.syslog is true then attempt to load the syslog bindings. If syslog
+    # cannot be loaded, then set Logger.syslog to false and continue.
+    #
+    # Returns nothing
+    def load_syslog
+      return unless Logger.syslog
+      
+      begin
+        require 'syslog'
+        
+        # Ensure that Syslog is open
+        begin
+          Syslog.open('god')
+        rescue RuntimeError
+          Syslog.reopen('god')
+        end
+      rescue Exception
+        Logger.syslog = false
       end
     end
     
+    # Log a message
+    #   +watch+ is the String name of the Watch (may be nil if not Watch is applicable)
+    #   +level+ is the log level [:debug|:info|:warn|:error|:fatal]
+    #   +text+ is the String message
+    #
+    # Returns nothing
     def log(watch, level, text)
       # initialize watch log if necessary
       self.logs[watch.name] ||= Timeline.new(God::LOG_BUFFER_SIZE_DEFAULT) if watch
       
       # push onto capture and timeline for the given watch
-      buf = StringIO.new
-      templog = ::Logger.new(buf)
-      templog.level = Logger::INFO
-      templog.send(level, text % [])
+      @templogio.truncate(0)
+      @templogio.rewind
+      @templog.send(level, text % [])
       @mutex.synchronize do
-        @capture.puts(buf.string) if @capture
-        self.logs[watch.name] << [Time.now, buf.string] if watch
+        @capture.puts(@templogio.string.dup) if @capture
+        self.logs[watch.name] << [Time.now, @templogio.string.dup] if watch
       end
-      templog.close
       
       # send to regular logger
       self.send(level, text % [])
       
       # send to syslog
-      Syslog.send(SYSLOG_EQUIVALENTS[level], text)
+      Syslog.send(SYSLOG_EQUIVALENTS[level], text) if Logger.syslog
     end
     
+    # Get all log output for a given Watch since a certain Time.
+    #   +watch_name+ is the String name of the Watch
+    #   +since+ is the Time since which to fetch log lines
+    #
+    # Returns String
     def watch_log_since(watch_name, since)
       # initialize watch log if necessary
       self.logs[watch_name] ||= Timeline.new(God::LOG_BUFFER_SIZE_DEFAULT)
@@ -65,6 +92,29 @@ module God
         end.join
       end
     end
+    
+    # private
+    
+    # Enable capturing of log
+    #
+    # Returns nothing
+    def start_capture
+      @mutex.synchronize do
+        @capture = StringIO.new
+      end
+    end
+    
+    # Disable capturing of log and return what was captured since
+    # capturing was enabled with Logger#start_capture
+    #
+    # Returns String
+    def finish_capture
+      @mutex.synchronize do
+        cap = @capture.string
+        @capture = nil
+        cap
+      end
+    end
   end
   
 end