mojombo-god 0.7.7 → 0.7.9

data/History.txt

@@ -1,4 +1,23 @@
-== _._._ / TBD
+== 0.7.10 / 
+  * Bug Fixes
+    * setup logging *after* loading a given config file when daemonized. 
+      enables logging to the 'God.log_file' specified in a config file. [github.com/jnewland]
+  * New Conditions
+    * FileMtime < PollCondition - trigger on file mtime durations [github.com/jwilkins]
+  * New Contacts
+    * Twitter - allow messages to twitter [github.com/jwilkins]
+    * Campfire - send messages to 37signals' Campfire [github.com/hellvinz]
+  * Minor Enhancements
+    * Add watch log_cmd that can be reopened with STDOUT instead of a log file [github.com/jberkel]
+    * Added webhook output support [Martyn Loughran]
+
+== 0.7.9 / 2008-08-06
+  * Major Enhancements
+    * Use a psuedo-priority queue for more efficient driver loop [Darrell Kresge]
+  * Bug Fixes
+    * Fix file_writable? when using chroot [github.com/eric]
+
+== 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]

data/Manifest.txt

@@ -24,6 +24,7 @@ lib/god/conditions/complex.rb
 lib/god/conditions/cpu_usage.rb
 lib/god/conditions/degrading_lambda.rb
 lib/god/conditions/disk_usage.rb
+lib/god/conditions/file_mtime.rb
 lib/god/conditions/flapping.rb
 lib/god/conditions/http_response_code.rb
 lib/god/conditions/lambda.rb
@@ -33,7 +34,11 @@ lib/god/conditions/process_running.rb
 lib/god/conditions/tries.rb
 lib/god/configurable.rb
 lib/god/contact.rb
+lib/god/contacts/campfire.rb
 lib/god/contacts/email.rb
+lib/god/contacts/jabber.rb
+lib/god/contacts/twitter.rb
+lib/god/contacts/webhook.rb
 lib/god/dependency_graph.rb
 lib/god/diagnostics.rb
 lib/god/driver.rb
@@ -82,6 +87,7 @@ test/configs/test.rb
 test/helper.rb
 test/suite.rb
 test/test_behavior.rb
+test/test_campfire.rb
 test/test_condition.rb
 test/test_conditions_disk_usage.rb
 test/test_conditions_http_response_code.rb
@@ -90,6 +96,7 @@ test/test_conditions_tries.rb
 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

data/Rakefile

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

data/lib/god.rb

@@ -49,13 +49,23 @@ require 'god/conditions/flapping'
 require 'god/conditions/http_response_code'
 require 'god/conditions/disk_usage'
 require 'god/conditions/complex'
+require 'god/conditions/file_mtime'
 
 require 'god/contact'
 require 'god/contacts/email'
+require 'god/contacts/webhook'
+begin
+  require 'god/contacts/twitter'
+rescue LoadError
+end
 begin
   require 'god/contacts/jabber'
 rescue LoadError
 end
+begin
+  require 'god/contacts/campfire'
+rescue LoadError
+end
 
 require 'god/socket'
 require 'god/driver'
@@ -138,7 +148,7 @@ class Module
 end
 
 module God
-  VERSION = '0.7.7'
+  VERSION = '0.7.9'
   
   LOG_BUFFER_SIZE_DEFAULT = 100
   PID_FILE_DIRECTORY_DEFAULTS = ['/var/run/god', '~/.god/pids']

data/lib/god/cli/run.rb

@@ -64,6 +64,7 @@ module God
           
           load_config @options[:config]
         end
+        setup_logging
       end
       
       def run_in_front
@@ -74,18 +75,6 @@ module God
         end
         
         default_run
-        
-        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
-          STDIN.reopen "/dev/null"
-          STDOUT.reopen(log_file, "a")
-          STDERR.reopen STDOUT
-          STDOUT.sync = true
-        end
       end
       
       def run_daemonized
@@ -96,14 +85,6 @@ module God
           begin
             require 'god'
             
-            log_file = @options[:log] || God.log_file || "/dev/null"
-            
-            # reset file descriptors
-            STDIN.reopen "/dev/null"
-            STDOUT.reopen(log_file, "a")
-            STDERR.reopen STDOUT
-            STDOUT.sync = true
-            
             # set pid if requested
             if @options[:pid] # and as deamon
               God.pid = @options[:pid] 
@@ -142,6 +123,21 @@ module God
         exit
       end
       
+      def setup_logging
+        log_file = God.log_file
+        log_file = File.expand_path(@options[:log]) if @options[:log]
+        log_file = "/dev/null" if !log_file && @options[:daemonize]
+        if log_file
+          puts "Sending output to log file: #{log_file}" unless @options[:daemonize]
+          
+          # reset file descriptors
+          STDIN.reopen "/dev/null"
+          STDOUT.reopen(log_file, "a")
+          STDERR.reopen STDOUT
+          STDOUT.sync = true
+        end
+      end
+      
       def load_config(config)
         if File.directory? config
           files_loaded = false

data/lib/god/conditions/file_mtime.rb

@@ -0,0 +1,28 @@
+module God
+  module Conditions
+
+    class FileMtime < PollCondition
+      attr_accessor :path, :max_age
+
+      def initialize
+        super
+        self.path = nil
+        self.max_age = nil
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'path' must be specified", self) if self.path.nil?
+        valid &= complain("Attribute 'max_age' must be specified", self) if self.max_age.nil?
+        valid
+      end
+
+      def test
+        (Time.now - File.mtime(self.path)) > self.max_age
+      end
+    end
+
+  end
+end
+
+

data/lib/god/contacts/campfire.rb

@@ -0,0 +1,82 @@
+# notify campfire using tinder http://tinder.rubyforge.org
+#
+#  Example: set up a new campfire notifier
+#
+#  Credentials
+#
+#  God::Contacts::Campfire.server_settings = {
+#     :subdomain => "yoursubdomain",
+#     :user_name => "youruser",
+#     :room => "yourroom",
+#     :password => "yourpassword"
+#  }
+#
+#  Register a new notifier
+#
+#  God.contact(:campfire) do |c|
+#     c.name = 'campfire'
+#  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 = 'campfire'
+#     end
+#   end
+
+require 'tinder'
+
+module God
+  module Contacts
+
+    class Campfire < Contact
+      class << self
+        attr_accessor :server_settings, :format
+      end
+
+      self.server_settings = {:subdomain => '',
+                              :user_name => '',
+                              :password => '',
+                              :room => ''}
+
+      self.format = lambda do |message, host|
+        <<-EOF
+        #{host} - #{message}
+        EOF
+      end
+
+      def initialize
+        @room = nil
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          body = Campfire.format.call(message,host)
+
+          room.speak body
+
+          self.info = "notified campfire: #{Campfire.server_settings[:subdomain]}"
+        rescue => e
+          applog(nil, :info, "failed to notify campfire: #{e.message}")
+          applog(nil, :debug, e.backtrace.join("\n"))
+        end
+      end
+
+      private
+
+      def room
+        unless @room
+          applog(nil,:debug, "initializing campfire connection using credentials: #{Campfire.server_settings.inspect}")
+
+          campfire = Tinder::Campfire.new Campfire.server_settings[:subdomain] 
+          campfire.login Campfire.server_settings[:user_name], Campfire.server_settings[:password]
+          @room = campfire.find_room_by_name(Campfire.server_settings[:room])
+        end
+        @room
+      end
+    end
+
+  end
+end

data/lib/god/contacts/jabber.rb

@@ -0,0 +1,65 @@
+# To add Jabber notifications you must have xmpp4r gem installed.
+# Configure your watches like this:
+#
+#   God::Contacts::Jabber.settings = { :jabber_id => 'sender@example.com',
+#                                      :password  => 'secret' }
+#   God.contact(:jabber) do |c|
+#     c.name      = 'Tester'
+#     c.jabber_id = 'receiver@example.com'
+#     c.group     = 'developers'
+#   end
+
+module XMPP4R
+  require 'rubygems'
+  require 'xmpp4r'
+  include Jabber
+end
+
+module God
+  module Contacts
+    class Jabber < Contact      
+      class << self
+        attr_accessor :settings, :format
+      end
+      
+      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
+      
+      attr_accessor :jabber_id
+      
+      def valid?
+        valid = true
+      end
+      
+      def notify(message, time, priority, category, host)
+        begin
+          jabber_id = XMPP4R::JID::new "#{Jabber.settings[:jabber_id]}/God"
+          jabber_client = XMPP4R::Client::new jabber_id
+          jabber_client.connect
+          jabber_client.auth Jabber.settings[:password]
+
+          body = Jabber.format.call message, priority, category, host
+          
+          message = XMPP4R::Message::new self.jabber_id, body
+          message.set_type :normal
+          message.set_id '1'
+          message.set_subject 'God'
+          jabber_client.send message
+
+          self.info = "sent jabber message to #{self.jabber_id}"
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+          
+          self.info = "failed to send jabber message to #{self.jabber_id}: #{e.message}"
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/contacts/twitter.rb

@@ -0,0 +1,39 @@
+# For Twitter updates you need the 'twitter' gem
+#   (gem install twitter)
+#
+# Configure your watches like this:
+#
+#   God::Contacts::Twitter.settings = { :username => 'sender@example.com',
+#                                       :password  => 'secret' }
+#   God.contact(:twitter) do |c|
+#     c.name      = 'Tester'
+#     c.group     = 'developers'
+#   end
+
+require 'rubygems'
+require 'twitter'
+
+module God
+  module Contacts
+    class Twitter < Contact
+      class << self
+        attr_accessor :settings
+      end
+
+      def valid?
+        valid = true
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          ::Twitter::Base.new(Twitter.settings[:username], 
+                              Twitter.settings[:password]).update(message)
+
+          self.info = "sent twitter update as #{Twitter.settings[:username]}"
+        rescue => e
+          self.info = "failed to send twitter update from #{self.twitter_id}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/god/contacts/webhook.rb

@@ -0,0 +1,47 @@
+# Configure your watches like this:
+#
+#   God.contact(:webhook) do |c|
+#     c.name      = 'Tester'
+#     c.hook_url  = 'http://hook/url'
+#   end
+
+require 'net/http'
+require 'uri'
+
+module God
+  module Contacts
+
+    class Webhook < Contact
+
+      attr_accessor :hook_url
+
+      def valid?
+        valid = true
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          data = {
+            :message => message,
+            :time => time,
+            :priority => priority,
+            :category => category,
+            :host => host
+          }
+
+          uri = URI.parse(self.hook_url)
+          Net::HTTP.post_form(uri, data)
+
+          self.info = "sent webhook to #{self.hook_url}"
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+
+          self.info = "failed to send webhook to #{self.hook_url}: #{e.message}"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/god/driver.rb

@@ -1,47 +1,171 @@
 module God
-  
-  class DriverEvent
-    attr_accessor :condition, :at
+  class TimedEvent
+    include Comparable
+
+    attr_accessor :at
     
-    # Instantiate a new TimerEvent that will be triggered after the specified delay
-    #   +condition+ is the Condition
+    # Instantiate a new TimedEvent that will be triggered after the specified delay
     #   +delay+ is the number of seconds from now at which to trigger
     #
-    # Returns TimerEvent
-    def initialize(condition, delay)
-      self.condition = condition
+    # Returns TimedEvent
+    def initialize(delay = 0)
       self.at = Time.now + delay
     end
-    
+
     def due?
       Time.now >= self.at
     end
+
+    def <=>(other)
+      self.at <=> other.at
+    end
+  end # DriverEvent
+
+  class DriverEvent < TimedEvent
+    attr_accessor :condition, :task
+    
+    def initialize(delay, task, condition)
+      super delay
+      self.task = task
+      self.condition = condition
+    end
+    
+    def handle_event
+      @task.handle_poll(@condition)
+    end
   end # DriverEvent
+
+  class DriverOperation < TimedEvent
+    attr_accessor :task, :name, :args
+
+    def initialize(task, name, args)
+      super(0)
+      self.task = task
+      self.name = name
+      self.args = args
+    end
+    
+    # Handle the next queued operation that was issued asynchronously
+    #
+    # Returns nothing
+    def handle_event
+      @task.send(@name, *@args)
+    end
+  end
   
+  class DriverEventQueue 
+    def initialize
+      @shutdown = false
+      @waiting = []
+      @events = []
+      @waiting.taint
+      @events.taint
+      self.taint
+    end
+
+    # 
+    # Wake any sleeping threads after setting the sentinel
+    # 
+    def shutdown
+      @shutdown = true
+      begin
+        Thread.critical = true
+        @waiting.each do |t|
+          t.run
+        end
+      ensure
+        Thread.critical = false
+      end
+    end
+
+    #
+    # Sleep until the queue has something due
+    #
+    def pop
+      begin
+        while (Thread.critical = true; @events.empty? or !@events.first.due?)
+          @waiting.push Thread.current
+          if @events.empty?
+            raise ThreadError, "queue empty" if @shutdown
+            Thread.stop
+          else
+            Thread.critical = false
+            sleep @events.first.at - Time.now
+            Thread.critical = true
+          end
+        end
+        @events.shift
+      ensure
+        Thread.critical = false
+      end
+    end
+
+    alias shift pop
+    alias deq pop
+
+    # 
+    # Add an event to the queue, wake any waiters if what we added needs to 
+    # happen sooner than the next pending event
+    #
+    def push(event)
+      Thread.critical = true
+      @events << event
+      @events.sort!
+      begin
+        t = @waiting.shift if @events.first == event
+        t.wakeup if t
+      rescue ThreadError
+        retry
+      ensure
+        Thread.critical = false
+      end
+      begin
+        t.run if t
+      rescue ThreadError
+      end
+    end
+
+    alias << push
+    alias enq push
+
+    def empty?
+      @que.empty?
+    end
+
+    def clear
+      @events.clear
+    end
+
+    def length
+      @events.length
+    end
+
+    alias size length
+
+    def num_waiting
+      @waiting.size
+    end
+  end
+
+
   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
+      @events = God::DriverEventQueue.new
       
       @thread = Thread.new do
         loop do
           begin
-            if !@ops.empty?
-              self.handle_op
-            elsif !@events.empty?
-              self.handle_event
-            else
-              sleep INTERVAL
-            end
+            @events.pop.handle_event
+          rescue ThreadError => e
+            # queue is empty
+            break
           rescue Exception => e
             message = format("Unhandled exception in driver loop - (%s): %s\n%s",
                              e.class, e.message, e.backtrace.join("\n"))
@@ -51,31 +175,8 @@ module God
       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
@@ -87,7 +188,7 @@ module God
     #
     # Returns nothing
     def message(name, args = [])
-      @ops.push([name, args])
+      @events.push(DriverOperation.new(@task, name, args))
     end
     
     # Create and schedule a new DriverEvent
@@ -98,11 +199,8 @@ module God
     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 }
+      @events.push(DriverEvent.new(delay, @task, condition))
     end
   end # Driver
   
-end # God
+end # God

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, :unix_socket, :chroot, :env
+    attr_accessor :name, :uid, :gid, :log, :log_cmd, :start, :stop, :restart, :unix_socket, :chroot, :env
     
     def initialize
       self.log = '/dev/null'
@@ -12,6 +12,7 @@ module God
       @user_log = false
       @pid = nil
       @unix_socket = nil
+      @log_cmd = nil
     end
     
     def alive?
@@ -28,10 +29,11 @@ module God
         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)
+        File.writable?(file_in_chroot(file)) ? exit(0) : exit(1)
       end
       
       wpid, status = ::Process.waitpid2(pid)
@@ -267,12 +269,17 @@ module God
 
         ::Dir.chroot(self.chroot) if self.chroot
         ::Process.setsid
+        ::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 file_in_chroot(self.log), "a"
+        if self.log_cmd
+          STDOUT.reopen IO.popen(self.log_cmd, "a") 
+        else
+          STDOUT.reopen file_in_chroot(self.log), "a"        
+        end
         STDERR.reopen STDOUT
         
         # close any other file descriptors

data/lib/god/system/slash_proc_poller.rb

@@ -15,7 +15,7 @@ module God
       # Returns true if +RequiredPaths+ are readable.
       def self.usable?
         RequiredPaths.all? do |path|
-          test(?r, path)
+          test(?r, path) && readable?(path)
         end
       end
       
@@ -57,6 +57,16 @@ module God
       
       private
       
+      # Some systems (CentOS?) have a /proc, but they can hang when trying to
+      # read from them. Try to use this sparingly as it is expensive.
+      def self.readable?(path)
+        begin
+          timeout(1) { File.read(path) }
+        rescue Timeout::Error
+          false
+        end
+      end
+      
       # in seconds
       def uptime
         File.read(UptimePath).split[0].to_f

data/lib/god/watch.rb

@@ -13,7 +13,7 @@ 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=, :log_cmd, :log_cmd=, :alive?, :pid,
                               :unix_socket, :unix_socket=, :chroot, :chroot=, :env, :env=
     # 
     def initialize

data/test/configs/contact/contact.god

@@ -6,6 +6,13 @@ God::Contacts::Email.server_settings = {
   :domain => "powerset.com"
 }
 
+God::Contacts::Twitter.settings = {
+  # this is for my 'mojombo2' twitter test account
+  # feel free to use it for testing your conditions
+  :username => 'mojombo@gmail.com',
+  :password  => 'gok9we3ot1av2e'
+}
+
 God.contact(:email) do |c|
   c.name = 'tom'
   c.email = 'tom@mojombo.com'
@@ -24,12 +31,15 @@ God.contact(:email) do |c|
   c.group = 'platform'
 end
 
+God.contact(:twitter) do |c|
+  c.name      = 'tom2'
+  c.group     = 'developers'
+end
+
 God.watch do |w|
   w.name = "contact"
   w.interval = 5.seconds
   w.start = "ruby " + File.join(File.dirname(__FILE__), *%w[simple_server.rb])
-  w.uid = 'tom'
-  w.gid = 'tom'
   w.log = "/Users/tom/contact.log"
   
   # determine the state on startup
@@ -55,7 +65,7 @@ God.watch do |w|
   # start if process is not running
   w.transition(:up, :start) do |on|
     on.condition(:process_exits) do |c|
-      c.notify = {:contacts => ['tom', 'foobar'], :priority => 1, :category => 'product'}
+      c.notify = {:contacts => ['tom2', 'foobar'], :priority => 1, :category => 'product'}
     end
   end
   

data/test/test_campfire.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/helper'
+require 'tinder'
+
+class TestCampfire < Test::Unit::TestCase
+  def test_exists
+    God::Contacts::Campfire
+  end
+  
+  # should notify
+  def test_campfire_delivery_method_for_notify
+    assert_nothing_raised do
+      
+      room = mock()
+      room.expects(:speak).returns(nil)
+      
+      g = God::Contacts::Campfire.new
+      God::Contacts::Campfire.format.expects(:call).with(:a,:e)
+      g.expects(:room).returns(room)
+      g.notify(:a, :b, :c, :d, :e)
+      assert_equal "notified campfire: ", g.info
+    end
+  end
+  
+  # should not establish a new connection because the older is alive
+  def test_campfire_room_method
+   assert_nothing_raised do
+     room = mock()
+     g = God::Contacts::Campfire.new
+     g.instance_variable_set(:@room,room)
+     assert_equal g.send(:room), room
+   end
+  end
+  
+  # should raise because the connections parameters have not been set
+  def test_campfire_delivery_method_for_notify_without_campfire_params
+    LOG.expects(:log).times(3) # 3 calls: 2 debug (credentials, backtrace) + 1 info (failed message)
+    g = God::Contacts::Campfire.new
+    g.notify(:a, :b, :c, :d, :e)
+  end
+  
+end

data/test/test_conditions_process_running.rb

@@ -6,7 +6,7 @@ class TestConditionsProcessRunning < Test::Unit::TestCase
       c = Conditions::ProcessRunning.new
       c.running = r
     
-      c.stubs(:watch).returns(stub(:pid => 123, :name => 'foo'))
+      c.stubs(:watch).returns(stub(:pid => 99999999, :name => 'foo'))
     
       # no_stdout do
         assert_equal !r, c.test

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mojombo-god
 version: !ruby/object:Gem::Version 
-  version: 0.7.7
+  version: 0.7.9
 platform: ruby
 authors: 
 - Tom Preston-Werner
@@ -50,6 +50,7 @@ files:
 - lib/god/conditions/cpu_usage.rb
 - lib/god/conditions/degrading_lambda.rb
 - lib/god/conditions/disk_usage.rb
+- lib/god/conditions/file_mtime.rb
 - lib/god/conditions/flapping.rb
 - lib/god/conditions/http_response_code.rb
 - lib/god/conditions/lambda.rb
@@ -59,7 +60,11 @@ files:
 - lib/god/conditions/tries.rb
 - lib/god/configurable.rb
 - lib/god/contact.rb
+- lib/god/contacts/campfire.rb
 - lib/god/contacts/email.rb
+- lib/god/contacts/jabber.rb
+- lib/god/contacts/twitter.rb
+- lib/god/contacts/webhook.rb
 - lib/god/dependency_graph.rb
 - lib/god/diagnostics.rb
 - lib/god/driver.rb
@@ -108,6 +113,7 @@ files:
 - test/helper.rb
 - test/suite.rb
 - test/test_behavior.rb
+- test/test_campfire.rb
 - test/test_condition.rb
 - test/test_conditions_disk_usage.rb
 - test/test_conditions_http_response_code.rb
@@ -116,6 +122,7 @@ 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