god 0.7.7 → 0.7.8

data/History.txt

@@ -1,4 +1,22 @@
-== 0.7.7 / TBD
+== 0.7.8 / 2008-07-09
+  * Bug Fixes
+    * Catch all Exceptions from HttpResponseCode condition [github.com/rliebling]
+    * Don't error out if the process went away in SlashProcPoller [Kevin Clark]
+    * Correction of Task#handle_poll to prevent crash under event registration failure conditions. [github.com/raggi]
+    * Cleaned up logging of failed e-mail sends. [github.com/raggi]
+    * Listen on 127.0.0.1 when using God as a client. [github.com/halorgium]
+  * New Behaviors
+    * clean_unix_socket [github.com/gma]
+  * New Contacts
+    * jabber [github.com/jwulff]
+    * email via sendmail [github.com/monde]
+  * Minor Enhancements
+    * chroot support [github.com/eric]
+    * Added God.log_file for the main god log, overridden by command line option. [github.com/raggi]
+    * Print groups from `god status` command if present [github.com/pdlug]
+    * Allow headers to be specified for http_response_code condition [github.com/pdlug]
+
+== 0.7.7 / 2008-06-17
   * Bug Fixes
     * Fix detection of proc file system [raggi]
 

data/Manifest.txt

@@ -13,6 +13,7 @@ init/god
 lib/god.rb
 lib/god/behavior.rb
 lib/god/behaviors/clean_pid_file.rb
+lib/god/behaviors/clean_unix_socket.rb
 lib/god/behaviors/notify_when_flapping.rb
 lib/god/cli/command.rb
 lib/god/cli/run.rb

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'hoe'
 
-Hoe.new('god', '0.7.7') do |p|
+Hoe.new('god', '0.7.8') do |p|
   p.rubyforge_name = 'god'
   p.author = 'Tom Preston-Werner'
   p.email = 'tom@rubyisawesome.com'

data/lib/god.rb

@@ -33,6 +33,7 @@ require 'god/task'
 
 require 'god/behavior'
 require 'god/behaviors/clean_pid_file'
+require 'god/behaviors/clean_unix_socket'
 require 'god/behaviors/notify_when_flapping'
 
 require 'god/condition'
@@ -51,6 +52,10 @@ require 'god/conditions/complex'
 
 require 'god/contact'
 require 'god/contacts/email'
+begin
+  require 'god/contacts/jabber'
+rescue LoadError
+end
 
 require 'god/socket'
 require 'god/driver'
@@ -133,7 +138,7 @@ class Module
 end
 
 module God
-  VERSION = '0.7.7'
+  VERSION = '0.7.8'
   
   LOG_BUFFER_SIZE_DEFAULT = 100
   PID_FILE_DIRECTORY_DEFAULTS = ['/var/run/god', '~/.god/pids']
@@ -149,6 +154,7 @@ module God
                        :allow,
                        :log_buffer_size,
                        :pid_file_directory,
+                       :log_file,
                        :log_level,
                        :use_events
     
@@ -460,7 +466,7 @@ module God
   def self.status
     info = {}
     self.watches.map do |name, w|
-      info[name] = {:state => w.state}
+      info[name] = {:state => w.state, :group => w.group}
     end
     info
   end
@@ -635,4 +641,4 @@ end
 # Returns nothing
 at_exit do
   God.at_exit if $run
-end
+end

data/lib/god/behaviors/clean_unix_socket.rb

@@ -0,0 +1,21 @@
+module God
+  module Behaviors
+    
+    class CleanUnixSocket < Behavior
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'unix_socket' must be specified", self) if self.watch.unix_socket.nil?
+        valid
+      end 
+      
+      def before_start 
+        File.delete(self.watch.unix_socket)
+        
+        "deleted unix socket" 
+      rescue 
+        "no unix socket to delete" 
+      end
+    end
+  
+  end
+end

data/lib/god/cli/command.rb

@@ -12,7 +12,7 @@ module God
       
       def setup
         # connect to drb unix socket
-        DRb.start_service
+        DRb.start_service("druby://127.0.0.1:0")
         @server = DRbObject.new(nil, God::Socket.socket(@options[:port]))
         
         # ping server to ensure that it is responsive
@@ -66,10 +66,21 @@ module God
       end
       
       def status_command
-        watches = @server.status
-        watches.keys.sort.each do |name|
-          state = watches[name][:state]
-          puts "#{name}: #{state}"
+        watches = {}
+        @server.status.each do |name, status|
+          g = status[:group] || ''
+          unless watches.has_key?(g)
+            watches[g] = {}
+          end
+          watches[g][name] = status
+        end
+        watches.keys.sort.each do |group|
+          puts "#{group}:" unless group.empty?
+          watches[group].keys.sort.each do |name|
+            state = watches[group][name][:state]
+            print "  " unless group.empty?
+            puts "#{name}: #{state}"
+          end
         end
       end
       
@@ -192,4 +203,4 @@ module God
     end # Command
     
   end
-end
+end

data/lib/god/cli/run.rb

@@ -75,8 +75,9 @@ module God
         
         default_run
         
-        if @options[:log]
-          log_file = File.expand_path(@options[:log])
+        log_file = God.log_file
+        log_file = File.expand_path(@options[:log]) if @options[:log]        
+        if log_file
           puts "Sending output to log file: #{log_file}"
           
           # reset file descriptors
@@ -95,7 +96,7 @@ module God
           begin
             require 'god'
             
-            log_file = @options[:log] || "/dev/null"
+            log_file = @options[:log] || God.log_file || "/dev/null"
             
             # reset file descriptors
             STDIN.reopen "/dev/null"

data/lib/god/conditions/http_response_code.rb

@@ -19,6 +19,7 @@ module God
     #  Optional
     #     +port+ is the port to connect (default 80)
     #     +path+ is the path to connect (default '/')
+    #     +headers+ is the hash of HTTP headers to send (default none)
     #     +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)
@@ -68,12 +69,14 @@ module God
                     :host,         # e.g. www.example.com
                     :port,         # e.g. 8080
                     :timeout,      # e.g. 60.seconds
-                    :path          # e.g. '/'
+                    :path,         # e.g. '/'
+                    :headers       # e.g. {'Host' => 'myvirtual.mydomain.com'}
       
       def initialize
         super
         self.port = 80
         self.path = '/'
+        self.headers = {}
         self.times = [1, 1]
         self.timeout = 60.seconds
       end
@@ -108,7 +111,7 @@ module God
         
         Net::HTTP.start(self.host, self.port) do |http|
           http.read_timeout = self.timeout
-          response = http.get(self.path)
+          response = http.get(self.path, self.headers)
         end
         
         actual_response_code = response.code.to_i
@@ -127,6 +130,10 @@ module God
         self.code_is ? fail('EOF') : pass('EOF')
       rescue Timeout::Error
         self.code_is ? fail('Timeout') : pass('Timeout')
+      rescue Errno::ETIMEDOUT
+        self.code_is ? fail('Timedout') : pass('Timedout')
+      rescue Exception => failure
+        self.code_is ? fail(failure.class.name) : pass(failure.class.name)
       end
       
       private

data/lib/god/contacts/email.rb

@@ -6,12 +6,12 @@ module God
     
     class Email < Contact
       class << self
-        attr_accessor :message_settings, :delivery_method, :server_settings, :format
+        attr_accessor :message_settings, :delivery_method, :server_settings, :sendmail_settings, :format
       end
       
       self.message_settings = {:from => 'god@example.com'}
       
-      self.delivery_method = :smtp
+      self.delivery_method = :smtp # or :sendmail
       
       self.server_settings = {:address => 'localhost',
                               :port => 25}
@@ -19,6 +19,10 @@ module God
                             # :user_name
                             # :password
                             # :authentication
+
+      self.sendmail_settings = {:location  => '/usr/sbin/sendmail',
+                                :arguments => '-i -t'
+      }
       
       self.format = lambda do |name, email, message, time, priority, category, host|
         <<-EOF
@@ -46,28 +50,46 @@ Category: #{category}
       def notify(message, time, priority, category, host)
         begin
           body = Email.format.call(self.name, self.email, message, time, priority, category, host)
-          
-          args = [Email.server_settings[:address], Email.server_settings[:port]]
-          if Email.server_settings[:authentication]
-            args << Email.server_settings[:domain]
-            args << Email.server_settings[:user_name]
-            args << Email.server_settings[:password]
-            args << Email.server_settings[:authentication] 
-          end
-            
-          Net::SMTP.start(*args) do |smtp|
-            smtp.send_message body, Email.message_settings[:from], self.email
+
+          case Email.delivery_method
+          when :smtp
+            notify_smtp(body)
+          when :sendmail
+            notify_sendmail(body)
+          else
+            raise "unknown delivery method: #{Email.delivery_method}"
           end
           
           self.info = "sent email to #{self.email}"
         rescue => e
-          puts e.message
-          puts e.backtrace.join("\n")
-          
-          self.info = "failed to send email to #{self.email}: #{e.message}"
+          applog(nil, :info, "failed to send email to #{self.email}: #{e.message}")
+          applog(nil, :debug, e.backtrace.join("\n"))
+        end
+      end
+
+      # private
+
+      def notify_smtp(mail)
+        args = [Email.server_settings[:address], Email.server_settings[:port]]
+        if Email.server_settings[:authentication]
+          args << Email.server_settings[:domain]
+          args << Email.server_settings[:user_name]
+          args << Email.server_settings[:password]
+          args << Email.server_settings[:authentication] 
+        end
+
+        Net::SMTP.start(*args) do |smtp|
+          smtp.send_message mail, Email.message_settings[:from], self.email
+        end
+      end
+
+      def notify_sendmail(mail)
+        IO.popen("#{Email.sendmail_settings[:location]} #{Email.sendmail_settings[:arguments]}","w+") do |sm|
+          sm.print(mail.gsub(/\r/, ''))
+          sm.flush
         end
       end
     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, :start, :stop, :restart
+    attr_accessor :name, :uid, :gid, :log, :start, :stop, :restart, :unix_socket, :chroot, :env
     
     def initialize
       self.log = '/dev/null'
@@ -11,6 +11,7 @@ module God
       @tracking_pid = true
       @user_log = false
       @pid = nil
+      @unix_socket = nil
     end
     
     def alive?
@@ -23,9 +24,14 @@ module God
     
     def file_writable?(file)
       pid = fork do
-        ::Process::Sys.setgid(Etc.getgrnam(self.gid).gid) if self.gid
-        ::Process::Sys.setuid(Etc.getpwnam(self.uid).uid) if self.uid
-        
+        uid_num = Etc.getpwnam(self.uid).uid if self.uid
+        gid_num = Etc.getgrnam(self.gid).gid if self.gid
+
+        ::Dir.chroot(self.chroot) if self.chroot
+        ::Process.groups = [gid_num] if self.gid
+        ::Process::Sys.setgid(gid_num) if self.gid
+        ::Process::Sys.setuid(uid_num) if self.uid
+
         File.writable?(file) ? exit(0) : exit(1)
       end
       
@@ -101,6 +107,19 @@ module God
           applog(self, :error, "Log directory '#{File.dirname(self.log)}' is not writable by #{self.uid || Etc.getlogin}")
         end
       end
+
+      # chroot directory must exist and have /dev/null in it
+      if self.chroot
+        if !File.directory?(self.chroot)
+          valid = false
+          LOG.log(self, :error, "CHROOT directory '#{self.chroot}' does not exist")
+        end
+
+        if !File.exist?(File.join(self.chroot, '/dev/null'))
+          valid = false
+          LOG.log(self, :error, "CHROOT directory '#{self.chroot}' does not contain '/dev/null'")
+        end
+      end
       
       valid
     end
@@ -244,18 +263,29 @@ module God
     # Returns nothing
     def spawn(command)
       fork do
+        uid_num = Etc.getpwnam(self.uid).uid if self.uid
+        gid_num = Etc.getgrnam(self.gid).gid if self.gid
+
+        ::Dir.chroot(self.chroot) if self.chroot
         ::Process.setsid
-        ::Process::Sys.setgid(Etc.getgrnam(self.gid).gid) if self.gid
-        ::Process::Sys.setuid(Etc.getpwnam(self.uid).uid) if self.uid
+        ::Process.groups = [gid_num] if self.gid
+        ::Process::Sys.setgid(gid_num) if self.gid
+        ::Process::Sys.setuid(uid_num) if self.uid
         Dir.chdir "/"
         $0 = command
         STDIN.reopen "/dev/null"
-        STDOUT.reopen self.log, "a"
+        STDOUT.reopen file_in_chroot(self.log), "a"
         STDERR.reopen STDOUT
         
         # close any other file descriptors
         3.upto(256){|fd| IO::new(fd).close rescue nil}
-        
+
+        if self.env && self.env.is_a?(Hash)
+          self.env.each do |(key, value)|
+            ENV[key] = value
+          end
+        end
+
         exec command unless command.empty?
       end
     end
@@ -286,6 +316,12 @@ module God
       ::Process.kill('KILL', self.pid) rescue nil
       applog(self, :warn, "#{self.name} process still running 10 seconds after stop command returned. Force killing.")
     end
-    
+
+    private
+    def file_in_chroot(file)
+      return file unless self.chroot
+
+      file.gsub(/^#{Regexp.escape(File.expand_path(self.chroot))}/, '')
+    end
   end
 end

data/lib/god/system/slash_proc_poller.rb

@@ -31,10 +31,14 @@ module God
       
       def memory
         stat[:rss].to_i * @@kb_per_page
+      rescue # This shouldn't fail is there's an error (or proc doesn't exist)
+        0
       end
       
       def percent_memory
         (memory / @@total_mem.to_f) * 100
+      rescue # This shouldn't fail is there's an error (or proc doesn't exist)
+        0
       end
       
       # TODO: Change this to calculate the wma instead
@@ -47,6 +51,8 @@ module God
         else
           ((total_time * 1000 / @@hertz) / seconds) / 10
         end
+      rescue # This shouldn't fail is there's an error (or proc doesn't exist)
+        0
       end
       
       private

data/lib/god/task.rb

@@ -19,7 +19,7 @@ module God
       self.behaviors = []
       
       # the list of conditions for each action
-      self.metrics = {nil => [], :unmonitored => []}
+      self.metrics = {nil => [], :unmonitored => [], :stop => []}
       
       # the condition -> metric lookup
       self.directory = {}
@@ -343,10 +343,10 @@ module God
         begin
           self.move(dest)
         rescue EventRegistrationFailedError
-          msg = watch.name + ' Event registration failed, moving back to previous state'
-          applog(watch, :info, msg)
+          msg = self.name + ' Event registration failed, moving back to previous state'
+          applog(self, :info, msg)
           
-          dest = watch.state
+          dest = self.state
           retry
         end
       else

data/lib/god/watch.rb

@@ -13,7 +13,8 @@ module God
     extend Forwardable
     def_delegators :@process, :name, :uid, :gid, :start, :stop, :restart,
                               :name=, :uid=, :gid=, :start=, :stop=, :restart=,
-                              :pid_file, :pid_file=, :log, :log=, :alive?, :pid
+                              :pid_file, :pid_file=, :log, :log=, :alive?, :pid,
+                              :unix_socket, :unix_socket=, :chroot, :chroot=, :env, :env=
     # 
     def initialize
       super
@@ -74,6 +75,12 @@ module God
       end
     end
     
+    def stop_if 
+      self.transition(:up, :stop) do |on| 
+        yield(on) 
+      end 
+    end
+    
     ###########################################################################
     #
     # Lifecycle
@@ -173,4 +180,4 @@ module God
     end
   end
   
-end
+end

data/test/helper.rb

@@ -6,11 +6,13 @@ require 'set'
 
 include God
 
-if RUBY_PLATFORM =~ /linux/i && Process.uid != 0
+if Process.uid != 0
   abort <<-EOF
+\n
 *********************************************************************
 *                                                                   *
-*    You need to run these tests as root (netlink requires it)      *
+*               You need to run these tests as root                 *
+*           chroot and netlink (linux only) require it              *
 *                                                                   *
 *********************************************************************
 EOF

data/test/test_email.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestEmail < Test::Unit::TestCase
+  def test_exists
+    God::Contacts::Email
+  end
+
+  def test_unknown_delivery_method_for_notify
+    assert_nothing_raised do
+      God::Contacts::Email.any_instance.expects(:notify_smtp).never
+      God::Contacts::Email.any_instance.expects(:notify_sendmail).never
+      God::Contacts::Email.delivery_method = :foo_protocol
+      LOG.expects(:log).times(2)
+ 
+      g = God::Contacts::Email.new
+      g.notify(:a, :b, :c, :d, :e)
+      assert_nil g.info
+    end
+  end
+
+  def test_smtp_delivery_method_for_notify
+    assert_nothing_raised do
+      God::Contacts::Email.any_instance.expects(:notify_sendmail).never
+      God::Contacts::Email.any_instance.expects(:notify_smtp).once.returns(nil)
+      God::Contacts::Email.delivery_method = :smtp
+      g = God::Contacts::Email.new
+      g.email = 'joe@example.com'
+      g.notify(:a, :b, :c, :d, :e)
+      assert_equal "sent email to joe@example.com", g.info
+    end
+  end
+  
+  def test_sendmail_delivery_method_for_notify
+    assert_nothing_raised do
+      God::Contacts::Email.any_instance.expects(:notify_smtp).never
+      God::Contacts::Email.any_instance.expects(:notify_sendmail).once.returns(nil)
+      God::Contacts::Email.delivery_method = :sendmail
+      g = God::Contacts::Email.new
+      g.email = 'joe@example.com'
+      g.notify(:a, :b, :c, :d, :e)
+      assert_equal "sent email to joe@example.com", g.info
+    end
+  end
+  
+end

data/test/test_god.rb

@@ -378,14 +378,22 @@ class TestGod < Test::Unit::TestCase
     
     w = God.watches['foo']
     w.state = :up
-    assert_equal({'foo' => {:state => :up}}, God.status)
+    assert_equal({'foo' => {:state => :up, :group => nil}}, God.status)
   end
   
+  def test_status_should_show_state_with_group
+    God.watch { |w| w.name = 'foo'; w.start = 'bar'; w.group = 'g' }
+    
+    w = God.watches['foo']
+    w.state = :up
+    assert_equal({'foo' => {:state => :up, :group => 'g'}}, God.status)
+  end
+
   def test_status_should_show_unmonitored_for_nil_state
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
     
     w = God.watches['foo']
-    assert_equal({'foo' => {:state => :unmonitored}}, God.status)
+    assert_equal({'foo' => {:state => :unmonitored, :group => nil}}, God.status)
   end
   
   # running_log
@@ -587,4 +595,4 @@ end
 #       God.validater
 #     end
 #   end
-# end
+# end

data/test/test_process.rb

@@ -68,7 +68,7 @@ class TestProcessChild < Test::Unit::TestCase
     assert @p.valid?
   end
   
-  def test_valid_should_return_true_if_gid_does_not_exists
+  def test_valid_should_return_false_if_gid_does_not_exists
     @p.start = 'qux'
     @p.log = '/tmp/foo.log'
     @p.gid = 'foobarbaz'
@@ -79,6 +79,28 @@ class TestProcessChild < Test::Unit::TestCase
       end
     end
   end
+
+  def test_valid_should_return_false_with_bogus_chroot
+    @p.chroot = '/bogusroot'
+
+    no_stdout do
+      no_stderr do
+        assert !@p.valid?
+      end
+    end
+  end
+
+  def test_valid_should_return_true_with_chroot_and_valid_log
+    @p.start = 'qux'
+    @p.chroot = '/tmp'
+    @p.log = '/tmp/foo.log'
+
+    File.expects(:exist?).with('/tmp').returns(true)
+    File.expects(:exist?).with('/tmp/foo.log').returns(true)
+    File.expects(:exist?).with('/tmp/dev/null').returns(true)
+
+    assert @p.valid?
+  end
   
   # call_action
   
@@ -172,12 +194,19 @@ class TestProcessDaemon < Test::Unit::TestCase
     assert_equal 246, @p.pid
   end
   
-  # defaul_pid_file
+  # default_pid_file
   
   def test_default_pid_file
     assert_equal File.join(God.pid_file_directory, 'foo.pid'), @p.default_pid_file
   end
   
+  # unix socket
+  
+  def test_unix_socket_should_return_path_specified
+    @p.unix_socket = '/path/to-socket'
+    assert_equal '/path/to-socket', @p.unix_socket
+  end
+  
   # call_action
   # These actually excercise call_action in the back at this point - Kev
   
@@ -214,4 +243,4 @@ class TestProcessDaemon < Test::Unit::TestCase
       @p.send("#{x}!")
     end
   end
-end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.4
 specification_version: 1
 name: god
 version: !ruby/object:Gem::Version 
-  version: 0.7.7
-date: 2008-06-17 00:00:00 -07:00
+  version: 0.7.8
+date: 2008-07-09 00:00:00 -07:00
 summary: Like monit, only awesome
 require_paths: 
 - lib
@@ -45,6 +45,7 @@ files:
 - lib/god.rb
 - lib/god/behavior.rb
 - lib/god/behaviors/clean_pid_file.rb
+- lib/god/behaviors/clean_unix_socket.rb
 - lib/god/behaviors/notify_when_flapping.rb
 - lib/god/cli/command.rb
 - lib/god/cli/run.rb
@@ -146,6 +147,7 @@ test_files:
 - test/test_contact.rb
 - test/test_dependency_graph.rb
 - test/test_driver.rb
+- test/test_email.rb
 - test/test_event_handler.rb
 - test/test_god.rb
 - test/test_handlers_kqueue_handler.rb