god 0.5.0 → 0.6.0

data/lib/god/conditions/memory_usage.rb

@@ -1,9 +1,38 @@
 module God
   module Conditions
     
+    # Condition Symbol :memory_usage
+    # Type: Poll
+    # 
+    # Trigger when the resident memory of a process is above a specified limit.
+    #
+    # Paramaters
+    #   Required
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #     +above+ is the amount of resident memory (in kilobytes) above which
+    #             the condition should trigger. You can also use the sugar
+    #             methods #kilobytes, #megabytes, and #gigabytes to clarify
+    #             this amount (see examples).
+    #
+    # Examples
+    #
+    # Trigger if the process is using more than 100 megabytes of resident
+    # memory (from a Watch):
+    #
+    #   on.condition(:memory_usage) do |c|
+    #     c.above = 100.megabytes
+    #   end
+    #
+    # Non-Watch Tasks must specify a PID file:
+    #
+    #   on.condition(:memory_usage) do |c|
+    #     c.above = 100.megabytes
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
     class MemoryUsage < PollCondition
       attr_accessor :above, :times
-    
+      
       def initialize
         super
         self.above = nil

data/lib/god/conditions/process_exits.rb

@@ -1,6 +1,27 @@
 module God
   module Conditions
     
+    # Condition Symbol :process_exits
+    # Type: Event
+    # 
+    # Trigger when a process exits.
+    #
+    # Paramaters
+    #   Required
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #
+    # Examples
+    #
+    # Trigger if process exits (from a Watch):
+    #
+    #   on.condition(:process_exits)
+    #
+    # Trigger if process exits:
+    #
+    #   on.condition(:process_exits) do |c|
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
     class ProcessExits < EventCondition
       def initialize
         self.info = "process exited"
@@ -16,7 +37,8 @@ module God
         pid = File.read(self.watch.pid_file).strip.to_i
         
         begin
-          EventHandler.register(pid, :proc_exit) do
+          EventHandler.register(pid, :proc_exit) do |extra|
+            self.info = "process exited #{extra.inspect}"
             Hub.trigger(self)
           end
         rescue StandardError
@@ -29,7 +51,7 @@ module God
           pid = File.read(self.watch.pid_file).strip.to_i
           EventHandler.deregister(pid, :proc_exit)
         else
-          LOG.log(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 such PID file #{self.watch.pid_file} (#{self.base_name})")
         end
       end
     end

data/lib/god/conditions/process_running.rb

@@ -1,6 +1,38 @@
 module God
   module Conditions
     
+    # Condition Symbol :process_running
+    # Type: Poll
+    # 
+    # Trigger when a process is running or not running depending on attributes.
+    #
+    # Paramaters
+    #   Required
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #     +running" specifies whether you want to trigger if the process is 
+    #               running (true) or whether it is not running (false)
+    #
+    # Examples
+    #
+    # Trigger if process IS NOT running (from a Watch):
+    #
+    #   on.condition(:process_running) do |c|
+    #     c.running = false
+    #   end
+    #
+    # Trigger if process IS running (from a Watch):
+    #
+    #   on.condition(:process_running) do |c|
+    #     c.running = true
+    #   end
+    #
+    # Non-Watch Tasks must specify a PID file:
+    #
+    #   on.condition(:process_running) do |c|
+    #     c.running = false
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
     class ProcessRunning < PollCondition
       attr_accessor :running
       

data/lib/god/configurable.rb

@@ -39,10 +39,12 @@ module God
     end
     
     def self.complain(text, c = nil)
-      msg = text
+      watch = c.watch rescue nil
+      msg = ""
+      msg += "#{watch.name}: " if watch
+      msg += text
       msg += " for #{c.friendly_name}" if c
-      Syslog.err(msg)
-      puts msg
+      applog(watch, :error, msg)
       false
     end
     

data/lib/god/event_handler.rb

@@ -50,8 +50,8 @@ module God
       end
     end
     
-    def self.call(pid, event)
-      @@actions[pid][event].call if watching_pid?(pid) && @@actions[pid][event]
+    def self.call(pid, event, extra_data = {})
+      @@actions[pid][event].call(extra_data) if watching_pid?(pid) && @@actions[pid][event]
     end
     
     def self.watching_pid?(pid)

data/lib/god/hub.rb

@@ -83,8 +83,7 @@ module God
                   watch.move(dest)
                 rescue EventRegistrationFailedError
                   msg = watch.name + ' Event registration failed, moving back to previous state'
-                  Syslog.debug(msg)
-                  LOG.log(watch, :info, msg)
+                  applog(watch, :info, msg)
                   
                   dest = watch.state
                   retry
@@ -95,11 +94,10 @@ module God
               end
             end
           end
-        rescue => e
+        rescue Exception => e
           message = format("Unhandled exception (%s): %s\n%s",
                            e.class, e.message, e.backtrace.join("\n"))
-          Syslog.crit message
-          abort message
+          applog(nil, :fatal, message)
         end
       end
     end
@@ -136,11 +134,10 @@ module God
               end
             end
           end
-        rescue => e
+        rescue Exception => e
           message = format("Unhandled exception (%s): %s\n%s",
                            e.class, e.message, e.backtrace.join("\n"))
-          Syslog.crit message
-          abort message
+          applog(nil, :fatal, message)
         end
       end
     end
@@ -165,19 +162,16 @@ module God
       if condition.info
         Array(condition.info).each do |condition_info|
           messages << "#{watch.name} #{status} #{condition_info} (#{condition.base_name})"
-          Syslog.debug(messages.last)
-          LOG.log(watch, :info, messages.last % [])
+          applog(watch, :info, messages.last)
         end
       else
         messages << "#{watch.name} #{status} (#{condition.base_name})"
-        Syslog.debug(messages.last)
-        LOG.log(watch, :info, messages.last % [])
+        applog(watch, :info, messages.last)
       end
       
       # log
       debug_message = watch.name + ' ' + condition.base_name + " [#{result}] " + self.dest_desc(metric, condition)
-      Syslog.debug(debug_message)
-      LOG.log(watch, :debug, debug_message)
+      applog(watch, :debug, debug_message)
       
       messages
     end
@@ -210,18 +204,17 @@ module God
       # warn about unmatched contacts
       unless unmatched.empty?
         msg = "#{condition.watch.name} no matching contacts for '#{unmatched.join(", ")}'"
-        LOG.log(condition.watch, :warn, msg)
+        applog(condition.watch, :warn, msg)
       end
       
       # notify each contact
       resolved_contacts.each do |c|
         host = `hostname`.chomp rescue 'none'
         c.notify(message, Time.now, spec[:priority], spec[:category], host)
-      
+        
         msg = "#{condition.watch.name} #{c.info ? c.info : "notification sent for contact: #{c.name}"} (#{c.base_name})"
-      
-        Syslog.debug(msg)
-        LOG.log(condition.watch, :info, msg % [])
+        
+        applog(condition.watch, :info, msg % [])
       end
     end
   end

data/lib/god/logger.rb

@@ -1,6 +1,12 @@
 module God
   
   class Logger < ::Logger
+    SYSLOG_EQUIVALENTS = {:fatal => :crit,
+                          :error => :err,
+                          :warn => :debug,
+                          :info => :debug,
+                          :debug => :debug}
+    
     attr_accessor :logs
     
     def initialize
@@ -32,7 +38,7 @@ module God
       buf = StringIO.new
       templog = ::Logger.new(buf)
       templog.level = Logger::INFO
-      templog.send(level, text)
+      templog.send(level, text % [])
       @mutex.synchronize do
         @capture.puts(buf.string) if @capture
         self.logs[watch.name] << [Time.now, buf.string] if watch
@@ -40,7 +46,10 @@ module God
       templog.close
       
       # send to regular logger
-      self.send(level, text)
+      self.send(level, text % [])
+      
+      # send to syslog
+      Syslog.send(SYSLOG_EQUIVALENTS[level], text)
     end
     
     def watch_log_since(watch_name, since)

data/lib/god/process.rb

@@ -44,13 +44,13 @@ module God
       # a start command must be specified
       if self.start.nil?
         valid = false
-        LOG.log(self, :error, "No start command was specified")
+        applog(self, :error, "No start command was specified")
       end
       
       # self-daemonizing processes must specify a stop command
       if !@tracking_pid && self.stop.nil?
         valid = false
-        LOG.log(self, :error, "No stop command was specified")
+        applog(self, :error, "No stop command was specified")
       end
       
       # uid must exist if specified
@@ -59,7 +59,7 @@ module God
           Etc.getpwnam(self.uid)
         rescue ArgumentError
           valid = false
-          LOG.log(self, :error, "UID for '#{self.uid}' does not exist")
+          applog(self, :error, "UID for '#{self.uid}' does not exist")
         end
       end
       
@@ -69,38 +69,38 @@ module God
           Etc.getgrnam(self.gid)
         rescue ArgumentError
           valid = false
-          LOG.log(self, :error, "GID for '#{self.gid}' does not exist")
+          applog(self, :error, "GID for '#{self.gid}' does not exist")
         end
       end
       
       # pid dir must exist if specified
       if !@tracking_pid && !File.exist?(File.dirname(self.pid_file))
         valid = false
-        LOG.log(self, :error, "PID file directory '#{File.dirname(self.pid_file)}' does not exist")
+        applog(self, :error, "PID file directory '#{File.dirname(self.pid_file)}' does not exist")
       end
       
       # pid dir must be writable if specified
-      if !@tracking_pid && !file_writable?(File.dirname(self.pid_file))
+      if !@tracking_pid && File.exist?(File.dirname(self.pid_file)) && !file_writable?(File.dirname(self.pid_file))
         valid = false
-        LOG.log(self, :error, "PID file directory '#{File.dirname(self.pid_file)}' is not writable by #{self.uid || Etc.getlogin}")
+        applog(self, :error, "PID file directory '#{File.dirname(self.pid_file)}' is not writable by #{self.uid || Etc.getlogin}")
       end
       
       # log dir must exist
       if !File.exist?(File.dirname(self.log))
         valid = false
-        LOG.log(self, :error, "Log directory '#{File.dirname(self.log)}' does not exist")
+        applog(self, :error, "Log directory '#{File.dirname(self.log)}' does not exist")
       end
       
       # log file or dir must be writable
       if File.exist?(self.log)
         unless file_writable?(self.log)
           valid = false
-          LOG.log(self, :error, "Log file '#{self.log}' exists but is not writable by #{self.uid || Etc.getlogin}")
+          applog(self, :error, "Log file '#{self.log}' exists but is not writable by #{self.uid || Etc.getlogin}")
         end
       else
         unless file_writable?(File.dirname(self.log))
           valid = false
-          LOG.log(self, :error, "Log directory '#{File.dirname(self.log)}' is not writable by #{self.uid || Etc.getlogin}")
+          applog(self, :error, "Log directory '#{File.dirname(self.log)}' is not writable by #{self.uid || Etc.getlogin}")
         end
       end
       
@@ -147,6 +147,9 @@ module God
         STDOUT.reopen self.log, "a"
         STDERR.reopen STDOUT
         
+        # close any other file descriptors
+        3.upto(256){|fd| IO::new(fd).close rescue nil}
+        
         exec command unless command.empty?
       end
     end
@@ -158,7 +161,7 @@ module God
         pid = File.read(self.pid_file).strip.to_i
         name = self.name
         command = lambda do
-          LOG.log(self, :info, "#{self.name} stop: default lambda killer")
+          applog(self, :info, "#{self.name} stop: default lambda killer")
           
           ::Process.kill('HUP', pid) rescue nil
           
@@ -185,16 +188,22 @@ module God
           # double fork god-daemonized processes
           # we don't want to wait for them to finish
           r, w = IO.pipe
-          opid = fork do
-            STDOUT.reopen(w)
-            r.close
-            pid = self.spawn(command)
-            puts pid.to_s
+          begin
+            opid = fork do
+              STDOUT.reopen(w)
+              r.close
+              pid = self.spawn(command)
+              puts pid.to_s # send pid back to forker
+            end
+            
+            ::Process.waitpid(opid, 0)
+            w.close
+            pid = r.gets.chomp
+          ensure
+            # make sure the file descriptors get closed no matter what
+            r.close rescue nil
+            w.close rescue nil
           end
-          
-          ::Process.waitpid(opid, 0)
-          w.close
-          pid = r.gets.chomp
         else
           # single fork self-daemonizing processes
           # we want to wait for them to finish

data/lib/god/socket.rb

@@ -1,57 +1,93 @@
 require 'drb'
 
-# The God::Server oversees the DRb server which dishes out info on this God daemon.
-
 module God
 
+  # The God::Server oversees the DRb server which dishes out info on this God daemon.
   class Socket
     attr_reader :port
     
+    # The location of the socket for a given port
+    #   +port+ is the port number
+    #
+    # Returns String (file location)
     def self.socket_file(port)
       "/tmp/god.#{port}.sock"
     end
     
+    # The address of the socket for a given port
+    #   +port+ is the port number
+    #
+    # Returns String (drb address)
     def self.socket(port)
       "drbunix://#{self.socket_file(port)}"
     end
     
+    # The location of the socket for this Server
+    #
+    # Returns String (file location)
     def socket_file
       self.class.socket_file(@port)
     end
     
+    # The address of the socket for this Server
+    #
+    # Returns String (drb address)
     def socket
       self.class.socket(@port)
     end
     
+    # Create a new Server and star the DRb server
+    #   +port+ is the port on which to start the DRb service (default nil)
     def initialize(port = nil)
       @port = port
       start
     end
     
+    # Returns true
     def ping
       true
     end
     
+    # Forward API calls to God
+    #
+    # Returns whatever the forwarded call returns
     def method_missing(*args, &block)
       God.send(*args, &block)
     end
     
+    # Stop the DRb server and delete the socket file
+    #
+    # Returns nothing
+    def stop
+      DRb.stop_service
+      FileUtils.rm_f(self.socket_file)
+    end
+    
     private
     
+    # Start the DRb server. Abort if there is already a running god instance
+    # on the socket.
+    #
+    # Returns nothing
     def start
       begin
         @drb ||= DRb.start_service(self.socket, self)
-        LOG.log(nil, :info, "Started on #{DRb.uri}")
+        applog(nil, :info, "Started on #{DRb.uri}")
       rescue Errno::EADDRINUSE
+        applog(nil, :info, "Socket already in use")
         DRb.start_service
         server = DRbObject.new(nil, self.socket)
         
         begin
-          server.ping
+          Timeout.timeout(5) do
+            server.ping
+          end
           abort "Socket #{self.socket} already in use by another instance of god"
-        rescue
+        rescue StandardError, Timeout::Error
+          applog(nil, :info, "Socket is stale, reopening")
           File.delete(self.socket_file) rescue nil
           @drb ||= DRb.start_service(self.socket, self)
+          applog(nil, :info, "Started on #{DRb.uri}")
         end
       end
     end