god 0.7.13 → 0.7.14

data/ideas/execve/execve.c

@@ -0,0 +1,29 @@
+#include "ruby.h"
+
+static VALUE mKernel;
+void Init_execve();
+VALUE method_execve(VALUE self, VALUE cmd, VALUE env);
+
+void Init_execve() {
+  mKernel = rb_const_get(rb_cObject, rb_intern("Kernel"));
+  rb_define_method(mKernel, "execve", method_execve, 2);
+}
+
+VALUE method_execve(VALUE self, VALUE r_cmd, VALUE r_env) {
+  char *shell = (char *)dln_find_exe("sh", 0);
+  char *arg[] = { "sh", "-c", StringValuePtr(r_cmd), (char *)0 };
+  
+  struct RArray *env_array;
+  env_array = RARRAY(r_env);
+  char *env[env_array->len + 1];
+  
+  int i;
+  for(i = 0; i < env_array->len; i++) {
+    env[i] = StringValuePtr(env_array->ptr[i]);
+  }
+  
+  env[env_array->len] = (char *)0;
+  
+  execve(shell, arg, env);
+  return Qnil;
+}

data/ideas/execve/extconf.rb

@@ -0,0 +1,11 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'execve'
+
+# The destination
+dir_config(extension_name)
+
+# Do the work
+create_makefile(extension_name)

data/ideas/execve/go.rb

@@ -0,0 +1,8 @@
+require 'execve'
+
+my_env = ENV.to_hash.merge('HOME' => '/foo')
+# my_env = ENV.to_hash
+
+env = my_env.keys.inject([]) { |acc, k| acc << "#{k}=#{my_env[k]}"; acc }
+
+execve(%Q{ruby -e "puts ENV['HOME']"}, env)

data/ideas/future.god

@@ -0,0 +1,82 @@
+# This example shows how you might keep a local development Rails server up
+# and running on your Mac.
+
+# Run with:
+# god -c /path/to/events.god
+
+RAILS_ROOT = "/Users/tom/dev/helloworld"
+
+God::Contacts::Email.delivery_method = :smtp
+God::Contacts::Email.server_settings = {}
+
+God.contact(:email) do |c|
+  c.name = 'tom'
+  c.email = 'tom@powerset.com'
+  c.group = 'developers'
+  c.throttle = 30.minutes
+end
+
+God.watch do |w|
+  w.name = "local-3000"
+  w.interval = 5.seconds
+  w.start = "mongrel_rails start -P ./log/mongrel.pid -c #{RAILS_ROOT} -d"
+  w.stop = "mongrel_rails stop -P ./log/mongrel.pid -c #{RAILS_ROOT}"
+  w.pid_file = File.join(RAILS_ROOT, "log/mongrel.pid")
+  
+  # clean pid files before start if necessary
+  w.behavior(:clean_pid_file)
+  
+  # determine the state on startup
+  w.transition(:init, { true => :up, false => :start }) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+  
+  # determine when process has finished starting
+  w.transition([:start, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_exits)
+  end
+  
+  # restart if memory or cpu is too high
+  w.transition(:up, :restart) do |on|
+    on.condition(:memory_usage) do |c|
+      c.interval = 20
+      c.above = 50.megabytes
+      c.times = [3, 5]
+    end
+    
+    on.condition(:cpu_usage) do |c|
+      c.interval = 10
+      c.above = 10.percent
+      c.times = [3, 5]
+    end
+  end
+  
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 5
+      c.within = 30.seconds
+      c.transition = nil
+      c.retry = 60.seconds
+      c.giveup_tries = 5
+      c.notify = 'tom'
+    end
+    
+    on.condition(:memory_usage) do |c|
+      c.interval = 20
+      c.above = 40.megabytes
+      c.times = [3, 5]
+      c.notify = 'tom'
+    end
+  end
+end

data/init/lsb_compliant_god

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+
+# see http://refspecs.freestandards.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
+
+PATH="/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin"
+DESC="god daemon"
+NAME="god"
+DAEMON="/usr/bin/#{NAME}"
+CONFIGFILE="/etc/god/god.conf"
+PIDFILE="/var/run/#{NAME}.pid"
+SCRIPTNAME="/etc/init.d/#{NAME}"
+START_FLAGS="--no-syslog -P #{PIDFILE}"
+
+ENV["PATH"] = PATH
+
+def read_pid
+  begin
+    @pid = File.read(PIDFILE).to_i
+    @pid = nil if @pid == 0
+  rescue
+    @pid = nil
+  end
+end
+
+def kill(code)
+  Process.kill(code, @pid)
+  true
+rescue
+  false
+end
+
+def running?
+  @pid && kill(0)
+end
+
+def dead?
+  @pid && !kill(0)
+end
+
+def start
+  if running?
+    puts "already running (#{@pid})"
+    exit
+  end
+
+  if dead?
+    clean_pid
+  end
+
+  puts "starting #{NAME}"
+  system("#{DAEMON} -c #{CONFIGFILE} #{START_FLAGS}")
+end
+
+def stop
+  if not running?
+    puts "not running"
+    exit
+  end
+
+	system("god quit")
+end
+
+def restart
+	if running?
+		stop
+		read_pid
+	end
+	start
+end
+
+def force_reload
+	if running?
+	  restart
+	end
+end
+
+def clean_pid
+  File.delete(PIDFILE)
+end
+
+read_pid
+case ARGV[0]
+when 'start'
+  start
+when 'stop'
+  stop
+when 'restart'
+  if not running?
+    start
+  else
+    restart
+  end
+when 'force-reload'
+  force_reload
+when 'status'
+  if running?
+    puts "running (#{@pid})"
+  elsif dead?
+    puts "dead (#{@pid})"
+    exit!(1)
+  else
+    puts "not running"
+    exit!(3)
+  end
+else
+  puts "Usage: #{SCRIPTNAME} start|stop|restart|force-reload|status"
+end
+
+exit

data/lib/god.rb

@@ -148,8 +148,6 @@ class Module
 end
 
 module God
-  VERSION = '0.7.13'
-  
   LOG_BUFFER_SIZE_DEFAULT = 100
   PID_FILE_DIRECTORY_DEFAULTS = ['/var/run/god', '~/.god/pids']
   DRB_PORT_DEFAULT = 17165
@@ -626,6 +624,11 @@ module God
     self.main.join
   end
   
+  def self.version
+    yml = YAML.load(File.read(File.join(File.dirname(__FILE__), *%w[.. VERSION.yml])))
+    "#{yml[:major]}.#{yml[:minor]}.#{yml[:patch]}"
+  end
+  
   # To be called on program exit to start god
   #
   # Returns nothing
@@ -654,7 +657,7 @@ module God
     
     list.select do |item|
       item =~ Regexp.new(regex)
-    end
+    end.sort_by { |x| x.size }
   end
 end
 

data/lib/god/cli/command.rb

@@ -117,11 +117,12 @@ module God
             exit!
           end
           
+          puts "Please wait..."
           t = Time.at(0)
           loop do
             print @server.running_log(name, t)
             t = Time.now
-            sleep 1
+            sleep 0.25
           end
         rescue God::NoSuchWatchError
           puts "No such watch"

data/lib/god/cli/version.rb

@@ -6,12 +6,12 @@ module God
         require 'god'
     
         # print version
-        puts "Version #{God::VERSION}"
+        puts "Version #{God.version}"
         exit
       end
       
       def self.version_extended
-        puts "Version: #{God::VERSION}"
+        puts "Version: #{God.version}"
         puts "Polls: enabled"
         puts "Events: " + God::EventHandler.event_system
     

data/lib/god/contacts/campfire.rb

@@ -39,7 +39,8 @@ module God
       self.server_settings = {:subdomain => '',
                               :user_name => '',
                               :password => '',
-                              :room => ''}
+                              :room => '',
+                              :ssl => false}
 
       self.format = lambda do |message, host|
         <<-EOF
@@ -70,7 +71,7 @@ module God
         unless @room
           applog(nil,:debug, "initializing campfire connection using credentials: #{Campfire.server_settings.inspect}")
 
-          campfire = Tinder::Campfire.new Campfire.server_settings[:subdomain] 
+          campfire = Tinder::Campfire.new Campfire.server_settings[:subdomain], :ssl => Campfire.server_settings[:ssl]
           campfire.login Campfire.server_settings[:user_name], Campfire.server_settings[:password]
           @room = campfire.find_room_by_name(Campfire.server_settings[:room])
         end

data/lib/god/contacts/jabber.rb

@@ -19,7 +19,7 @@ module God
   module Contacts
     class Jabber < Contact      
       class << self
-        attr_accessor :settings, :format
+        attr_accessor :settings, :format, :client
       end
       
       self.format = lambda do |message, priority, category, host|
@@ -37,29 +37,91 @@ module God
       end
       
       def notify(message, time, priority, category, host)
+        connect
+        
+        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'
+        
+        self.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
+      
+      def send!(msg)
+        attempts = 0
         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
+          attempts += 1
+          client.send(msg)
+        rescue Errno::EPIPE, IOError => e
+          sleep 1
+          disconnect!
+          reconnect!
+          retry unless attempts > 3
+          raise e
+        rescue Errno::ECONNRESET => e
+          sleep (attempts^2) * 60 + 60
+          disconnect!
+          reconnect!
+          retry unless attempts > 3
+          raise e
+        end
+      end
+      
+      def connect
+        connect! unless connected?
+      end
+      
+      def connected?
+        connected = client.respond_to?(:is_connected?) && client.is_connected?
+        return connected
+      end
+      
+      def connect!
+        disconnect! if connected?
 
-          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}"
+        @connect_mutex ||= Mutex.new
+        # don't try to connect if another thread is already connecting.
+        return if @connect_mutex.locked?
+        @connect_mutex.lock
+        
+        jabber_id = XMPP4R::JID::new "#{Jabber.settings[:jabber_id]}/God"
+        jabber_client = XMPP4R::Client::new jabber_id
+        jabber_client.connect Jabber.settings[:host]
+        jabber_client.auth Jabber.settings[:password]
+        self.client = jabber_client
+        
+        @connect_mutex.unlock
+      end
+      
+      def disconnect!
+        if client.respond_to?(:is_connected?) && client.is_connected?
+          begin
+            client.close
+          rescue Errno::EPIPE, IOError => e
+            self.info "Failed to disconnect: #{e}"
+            nil
+          end
         end
+        client = nil
+      end
+
+      def client
+        Jabber.client
+      end
+
+      def client=(jc)
+        Jabber.client = jc
       end
+
     end
-    
   end
 end