god 0.8.0 → 0.9.0

data/lib/god.rb

@@ -63,6 +63,11 @@ begin
   require 'god/contacts/campfire'
 rescue LoadError
 end
+begin
+  require 'god/contacts/prowl'
+rescue LoadError
+end
+
 
 require 'god/socket'
 require 'god/driver'
@@ -145,11 +150,13 @@ class Module
 end
 
 module God
+  VERSION = '0.9.0'
   LOG_BUFFER_SIZE_DEFAULT = 100
   PID_FILE_DIRECTORY_DEFAULTS = ['/var/run/god', '~/.god/pids']
   DRB_PORT_DEFAULT = 17165
   DRB_ALLOW_DEFAULT = ['127.0.0.1']
   LOG_LEVEL_DEFAULT = :info
+  TERMINATE_TIMEOUT_DEFAULT = 10
   
   class << self
     # user configurable
@@ -161,7 +168,11 @@ module God
                        :pid_file_directory,
                        :log_file,
                        :log_level,
-                       :use_events
+                       :use_events,
+                       :terminate_timeout,
+                       :socket_user,
+                       :socket_group,
+                       :socket_perms
     
     # internal
     attr_accessor :inited,
@@ -184,6 +195,10 @@ module God
   self.log_buffer_size = nil
   self.pid_file_directory = nil
   self.log_level = nil
+  self.terminate_timeout = nil
+  self.socket_user = nil
+  self.socket_group = nil
+  self.socket_perms = 0755
   
   # Initialize internal data.
   #
@@ -205,6 +220,7 @@ module God
     self.port ||= DRB_PORT_DEFAULT
     self.allow ||= DRB_ALLOW_DEFAULT
     self.log_level ||= LOG_LEVEL_DEFAULT
+    self.terminate_timeout ||= TERMINATE_TIMEOUT_DEFAULT
     
     # additional setup
     self.setup
@@ -441,7 +457,7 @@ module God
       end
     end
     
-    10.times do
+    terminate_timeout.times do
       return true unless self.watches.map { |name, w| w.alive? }.any?
       sleep 1
     end
@@ -592,6 +608,12 @@ module God
       end
     end
     
+    if God::Logger.syslog
+      LOG.info("Syslog enabled.")
+    else
+      LOG.info("Syslog disabled.")
+    end
+    
     applog(nil, :info, "Using pid file directory: #{self.pid_file_directory}")
   end
   
@@ -602,7 +624,7 @@ module God
     self.internal_init
     
     # instantiate server
-    self.server = Socket.new(self.port)
+    self.server = Socket.new(self.port, self.socket_user, self.socket_group, self.socket_perms)
     
     # start monitoring any watches set to autostart
     self.watches.values.each { |w| w.monitor if w.autostart? }
@@ -625,8 +647,7 @@ module God
   end
   
   def self.version
-    yml = YAML.load(File.read(File.join(File.dirname(__FILE__), *%w[.. VERSION.yml])))
-    "#{yml[:major]}.#{yml[:minor]}.#{yml[:patch]}"
+    God::VERSION
   end
   
   # To be called on program exit to start god

data/lib/god/cli/command.rb

@@ -172,7 +172,7 @@ module God
           puts 'Stopped all watches'
         else
           t.kill; STDOUT.puts
-          puts 'Could not stop all watches within 10 seconds'
+          puts "Could not stop all watches within #{@server.terminate_timeout} seconds"
         end
         
         begin

data/lib/god/cli/run.rb

@@ -12,6 +12,10 @@ module God
         # have at_exit start god
         $run = true
         
+        if @options[:syslog]
+          require 'god/sys_logger'
+        end
+        
         # run
         if @options[:daemonize]
           run_daemonized
@@ -36,7 +40,7 @@ module God
       def default_run
         # make sure we have STDIN/STDOUT redirected immediately
         setup_logging
-
+        
         # start attached pid watcher if necessary
         if @options[:attach]
           self.attach
@@ -93,10 +97,6 @@ module God
               God.pid = @options[:pid] 
             end
             
-            unless @options[:syslog]
-              Logger.syslog = false
-            end
-            
             default_run
             
             unless God::EventHandler.loaded?

data/lib/god/compat19.rb

@@ -0,0 +1,36 @@
+
+require 'monitor'
+
+
+# Taken from http://redmine.ruby-lang.org/repositories/entry/ruby-19/lib/monitor.rb
+
+module MonitorMixin
+  class ConditionVariable
+    def wait(timeout = nil)
+      @monitor.__send__(:mon_check_owner)
+      count = @monitor.__send__(:mon_exit_for_cond)
+      begin
+        @cond.wait(@monitor.instance_variable_get("@mon_mutex"), timeout)
+        return true
+      ensure
+        @monitor.__send__(:mon_enter_for_cond, count)
+      end
+    end
+  end
+end
+
+
+# Taken from http://redmine.ruby-lang.org/repositories/entry/ruby-19/lib/thread.rb
+
+class ConditionVariable
+  def wait(mutex, timeout=nil)
+    begin
+      # TODO: mutex should not be used
+      @waiters_mutex.synchronize do
+        @waiters.push(Thread.current)
+      end
+      mutex.sleep timeout
+    end
+    self
+  end
+end

data/lib/god/contacts/prowl.rb

@@ -0,0 +1,77 @@
+# For Prowl notifications you need the 'prowly' gem
+#   (gem install prowly)
+#
+# Configure your watches like this:
+#
+#   God.contact(:prowl) do |c|
+#     c.name      = 'georgette'
+#     c.apikey    = 'ffffffffffffffffffffffffffffffffffffffff'
+#     c.group     = 'developers'
+#   end
+#
+#
+#   God.contact(:prowl) do |c|
+#     c.name      = 'johnny'
+#     c.apikey    = 'ffffffffffffffffffffffffffffffffffffffff'
+#     c.group     = 'developers'
+#   end
+#
+#
+#  Define a transition for the process running event
+#
+#   w.transition(:up, :start) do |on|
+#     on.condition(:process_running) do |c|
+#        c.running = true
+#        c.notify = 'developers'
+#     end
+#   end
+
+require 'prowly'
+
+module God
+  module Contacts
+    class Prowl < Contact
+
+      attr_accessor :apikey
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'apikey' must be specified", self) if self.apikey.nil?
+        valid
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          result = Prowly.notify do |n|
+            n.apikey      = self.apikey
+            n.priority    = map_priority(priority.to_i)
+            n.application = category || "God"
+            n.event       = "on " + host.to_s
+            n.description = message.to_s + " at " + time.to_s
+          end
+
+          if result.succeeded?
+            self.info = "sent prowl notification to #{self.name}"
+          else
+            self.info = "failed to send prowl notification to #{self.name}: #{result.message}"
+          end
+        end
+      rescue Object => e
+        self.info = "failed to send prowl notification to #{self.name}: #{e.message}"
+      end
+
+      private
+
+      def map_priority(priority)
+        case priority
+           when 1 then Prowly::Notification::Priority::EMERGENCY
+           when 2 then Prowly::Notification::Priority::HIGH
+           when 3 then Prowly::Notification::Priority::NORMAL
+           when 4 then Prowly::Notification::Priority::MODERATE
+           when 5 then Prowly::Notification::Priority::VERY_LOW
+           else Prowly::Notification::Priority::NORMAL
+        end
+      end
+    end
+  end
+end

data/lib/god/contacts/scout.rb

@@ -0,0 +1,64 @@
+# Configure your Scout client key:
+#
+#   God::Contacts::Scout.client_key = '1qpw29ie38ur37yt5
+#
+# A client key is configured per god process. Inside this God process,
+# you can create multiple Scout 'contacts' - which are actually Scout
+# plugins. This allows you to use Scout's UI to configure who gets
+# notifications for each plugin, and to disable notifications when you
+# go on vacation, etc.
+#
+#   God.contact(:scout) do |c|
+#     c.name      = 'scout_delayed_job_plugin'
+#     c.plugin_id = '12345
+#   end
+#
+#   God.contact(:scout) do |c|
+#     c.name      = 'scout_apache_plugin'
+#     c.plugin_id = '54312
+#   end
+
+require 'net/http'
+require 'uri'
+
+module God
+  module Contacts
+    class Scout < Contact
+      class << self
+        attr_accessor :client_key, :format
+      end
+      attr_accessor :plugin_id
+
+      self.format = lambda do |message, priority, category, host|
+        text  = "Message: #{message}\n"
+        text += "Host: #{host}\n"         if host
+        text += "Priority: #{priority}\n" if priority
+        text += "Category: #{category}\n" if category
+        return text
+      end
+
+      def valid?
+        valid = true
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          data = {
+            :client_key => Scout.client_key,
+            :plugin_id => plugin_id,
+            :format => 'xml',
+            'alert[subject]' => message,
+            'alert[body]' => Scout.format.call(message, priority, category, host)
+          }
+
+          uri = URI.parse('http://scoutapp.com/alerts/create')
+          Net::HTTP.post_form(uri, data)
+
+          self.info = "sent scout alert to plugin ##{plugin_id}"
+        rescue => e
+          self.info = "failed to send scout alert to plugin ##{plugin_id}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/god/driver.rb

@@ -1,5 +1,10 @@
 require 'monitor'
 
+# ruby 1.9 specific fixes
+unless RUBY_VERSION < '1.9'
+  require 'god/compat19'
+end
+
 module God
   class TimedEvent
     include Comparable

data/lib/god/logger.rb

@@ -1,19 +1,14 @@
 module God
   
   class Logger < SimpleLogger
-    SYSLOG_EQUIVALENTS = {:fatal => :crit,
-                          :error => :err,
-                          :warn => :debug,
-                          :info => :debug,
-                          :debug => :debug}
-    
+
     attr_accessor :logs
     
     class << self
       attr_accessor :syslog
     end
     
-    self.syslog ||= true
+    self.syslog = defined?(Syslog)
     
     # Instantiate a new Logger object
     def initialize(io = $stdout)
@@ -25,28 +20,12 @@ module God
       @templogio = StringIO.new
       @templog = SimpleLogger.new(@templogio)
       @templog.level = Logger::INFO
-      load_syslog
     end
     
-    # 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
+    
+    def level=(lev)
+      SysLogger.level = SimpleLogger::CONSTANT_TO_SYMBOL[lev] if Logger.syslog
+      super(lev)
     end
     
     # Log a message
@@ -80,7 +59,7 @@ module God
       self.send(level, text)
 
       # send to syslog
-      Syslog.send(SYSLOG_EQUIVALENTS[level], text) if Logger.syslog
+      SysLogger.log(level, text) if Logger.syslog
     end
     
     # Get all log output for a given Watch since a certain Time.
@@ -127,4 +106,4 @@ module God
     end
   end
   
-end
+end

data/lib/god/process.rb

@@ -2,7 +2,7 @@ module God
   class Process
     WRITES_PID = [:start, :restart]
     
-    attr_accessor :name, :uid, :gid, :log, :log_cmd, :start, :stop, :restart,
+    attr_accessor :name, :uid, :gid, :log, :log_cmd, :err_log, :err_log_cmd, :start, :stop, :restart,
                   :unix_socket, :chroot, :env, :dir
     
     def initialize
@@ -300,7 +300,13 @@ module God
         else
           STDOUT.reopen file_in_chroot(self.log), "a"        
         end
-        STDERR.reopen STDOUT
+        if err_log_cmd
+          STDERR.reopen IO.popen(err_log_cmd, "a") 
+        elsif err_log && (log_cmd || err_log != log)
+          STDERR.reopen file_in_chroot(err_log), "a"        
+        else
+          STDERR.reopen STDOUT
+        end
         
         # close any other file descriptors
         3.upto(256){|fd| IO::new(fd).close rescue nil}

data/lib/god/simple_logger.rb

@@ -13,6 +13,12 @@ module God
                  ERROR => 'ERROR',
                  FATAL => 'FATAL'}
     
+    CONSTANT_TO_SYMBOL = { DEBUG => :debug,
+                           INFO => :info,
+                           WARN => :warn,
+                           ERROR => :error,
+                           FATAL => :fatal }
+    
     attr_accessor :datetime_format, :level
     
     def initialize(io)
@@ -26,7 +32,7 @@ module God
       
       time = Time.now.strftime(self.datetime_format)
       label = SEV_LABEL[level]
-      @io.print(label[0..0], ' [', time, '] ', label.rjust(5), ': ',  msg, "\n")
+      @io.puts("#{label[0..0]} [#{time}] #{label.rjust(5)}: #{msg}")
     end
     
     def fatal(msg)

data/lib/god/socket.rb

@@ -38,8 +38,11 @@ module God
     
     # 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
+    def initialize(port = nil, user = nil, group = nil, perm = nil)
+      @port  = port
+      @user  = user
+      @group = group
+      @perm  = perm
       start
     end
     
@@ -90,6 +93,14 @@ module God
           applog(nil, :info, "Started on #{DRb.uri}")
         end
       end
+
+      if File.exists?(self.socket_file)
+        uid = Etc.getpwnam(@user).uid if @user
+        gid = Etc.getgrnam(@group).gid if @group
+
+        File.chmod(Integer(@perm), socket_file) if @perm
+        File.chown(uid, gid, socket_file) if uid or gid
+      end
     end
   end