god 0.2.0 → 0.3.0

data/ext/god/kqueue_handler.c

@@ -5,9 +5,9 @@
 #include <sys/time.h>
 #include <errno.h>
 
+static VALUE mGod;
 static VALUE cKQueueHandler;
 static VALUE cEventHandler;
-static VALUE mGod;
 
 static ID proc_exit;
 static ID proc_fork;
@@ -119,4 +119,4 @@ Init_kqueue_handler_ext()
   rb_define_singleton_method(cKQueueHandler, "event_mask", kqh_event_mask, 1);
 }
 
-#endif
+#endif

data/ext/god/netlink_handler.c

@@ -2,15 +2,16 @@
 
 #include <ruby.h>
 #include <sys/types.h>
+#include <unistd.h>
 #include <sys/socket.h>
 #include <linux/netlink.h>
 #include <linux/connector.h>
 #include <linux/cn_proc.h>
 #include <errno.h>
 
+static VALUE mGod;
 static VALUE cNetlinkHandler;
 static VALUE cEventHandler;
-static VALUE mGod;
 
 static ID proc_exit;
 static ID proc_fork;
@@ -71,6 +72,12 @@ nlh_handle_events()
       
         rb_funcall(cEventHandler, m_call, 2, INT2FIX(event->event_data.fork.parent_pid), ID2SYM(proc_fork));
         return INT2FIX(1);
+
+      case PROC_EVENT_NONE:
+      case PROC_EVENT_EXEC:
+      case PROC_EVENT_UID:
+      case PROC_EVENT_GID:
+        break;
     }
   }
   
@@ -87,17 +94,23 @@ connect_to_netlink()
   struct sockaddr_nl sa_nl; /* netlink interface info */
   char buff[NL_MESSAGE_SIZE];
   struct nlmsghdr *hdr; /* for telling netlink what we want */
-  struct cn_msg *msg;   /* the actual connector message
+  struct cn_msg *msg;   /* the actual connector message */
   
   /* connect to netlink socket */
   nl_sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
   
+  if (-1 == nl_sock) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
+  
   bzero(&sa_nl, sizeof(sa_nl));
   sa_nl.nl_family = AF_NETLINK;
   sa_nl.nl_groups = CN_IDX_PROC;
   sa_nl.nl_pid    = getpid();
   
-  bind(nl_sock, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
+  if (-1 == bind(nl_sock, (struct sockaddr *)&sa_nl, sizeof(sa_nl))) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
   
   /* Fill header */
   hdr = (struct nlmsghdr *)buff;
@@ -137,4 +150,4 @@ Init_netlink_handler_ext()
   connect_to_netlink();
 }
 
-#endif
+#endif

data/lib/god.rb

@@ -1,7 +1,8 @@
 $:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
 
+require 'syslog'
+
 # internal requires
-require 'god/base'
 require 'god/errors'
 
 require 'god/system/process'
@@ -23,46 +24,147 @@ require 'god/timer'
 require 'god/hub'
 
 require 'god/metric'
-
 require 'god/watch'
-require 'god/meddle'
 
 require 'god/event_handler'
+require 'god/registry'
+require 'god/process'
+
+require 'god/sugar'
 
-Thread.abort_on_exception = true
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. ext god])
+
+begin
+  Syslog.open('god')
+rescue RuntimeError
+  Syslog.reopen('god')
+end
+
+God::EventHandler.load
 
 module God
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
+  
+  class << self
+    attr_accessor :inited, :host, :port
+    
+    # drb
+    attr_accessor :server
+    
+    # api
+    attr_accessor :watches, :groups
+  end
+  
+  def self.init
+    # only do this once
+    return if self.inited
+    
+    # variable init
+    self.watches = {}
+    self.groups = {}
+    
+    # yield to the config file
+    yield self if block_given?
+    
+    # instantiate server
+    self.server = Server.new(self.host, self.port)
+    
+    # init has been executed
+    self.inited = true
+  end
+    
+  # Where pid files created by god will go by default
+  def self.pid_file_directory
+    @pid_file_directory ||= '/var/run/god'
+  end
   
-  case RUBY_PLATFORM
-  when /darwin/i, /bsd/i
-    $:.unshift File.join(File.dirname(__FILE__), *%w[.. ext god])
-    require 'god/event_handlers/kqueue_handler'
-    EventHandler.handler = KQueueHandler
-  when /linux/i
-    $:.unshift File.join(File.dirname(__FILE__), *%w[.. ext god])
-    require 'god/event_handlers/netlink_handler'
-    EventHandler.handler = NetlinkHandler
-  else
-    raise NotImplementedError, "Platform not supported for EventHandler"
+  def self.pid_file_directory=(value)
+    @pid_file_directory = value
   end
   
-  def self.meddle(options = {})  
-    m = Meddle.new(options)
+  # Instantiate a new, empty Watch object and pass it to the mandatory
+  # block. The attributes of the watch will be set by the configuration
+  # file.
+  def self.watch
+    self.init
     
-    # yeild to the config file
-    yield m
+    w = Watch.new
+    yield(w)
+    
+    # ensure the new watch has a unique name
+    if self.watches[w.name] || self.groups[w.name]
+      abort "Watch name '#{w.name}' already used for a Watch or Group"
+    end
+    
+    # add to list of watches
+    self.watches[w.name] = w
+    
+    # add to group if specified
+    if w.group
+      # ensure group name hasn't been used for a watch already
+      if self.watches[w.group]
+        abort "Group name '#{w.group}' already used for a Watch"
+      end
+    
+      self.groups[w.group] ||= []
+      self.groups[w.group] << w.name
+    end
+
+    # register watch
+    w.register!
+  end
+  
+  def self.control(name, command)
+    # get the list of watches
+    watches = Array(self.watches[name] || self.groups[name])
+  
+    # do the command
+    case command
+      when "start", "monitor"
+        watches.each { |w| w.monitor }
+      when "restart"
+        watches.each { |w| w.move(:restart) }
+      when "stop"
+        watches.each { |w| w.unmonitor.action(:stop) }
+      when "unmonitor"
+        watches.each { |w| w.unmonitor }
+      else
+        raise InvalidCommandError.new
+    end
+    
+    watches
+  end
+    
+  def self.start
+    # make sure there's something to do
+    if self.watches.nil? || self.watches.empty?
+      abort "You must specify at least one watch!"
+    end
     
     # start event handler system
-    EventHandler.start
+    EventHandler.start if EventHandler.loaded?
     
     # start the timer system
     Timer.get
 
-    # start monitoring each watch
-    m.monitor
+    # start monitoring any watches set to autostart
+    self.watches.values.each { |w| w.monitor if w.autostart? }
     
-    # join the timer thread to we don't exit
+    # join the timer thread so we don't exit
     Timer.get.join
-  end  
+  end
+  
+  def self.at_exit
+    self.start
+  end
+  
+  def self.load(glob)
+    Dir[glob].each do |f|
+      Kernel.load f
+    end
+  end
 end
+
+at_exit do
+  God.at_exit
+end

data/lib/god/behavior.rb

@@ -1,12 +1,16 @@
 module God
   
-  class Behavior < Base
+  class Behavior
+    attr_accessor :watch
+    
     # Generate a Behavior of the given kind. The proper class if found by camel casing the
     # kind (which is given as an underscored symbol).
     #   +kind+ is the underscored symbol representing the class (e.g. foo_bar for God::Behaviors::FooBar)
-    def self.generate(kind)
+    def self.generate(kind, watch)
       sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
-      God::Behaviors.const_get(sym).new
+      b = God::Behaviors.const_get(sym).new
+      b.watch = watch
+      b
     rescue NameError
       raise NoSuchBehaviorError.new("No Behavior found with the class name God::Behaviors::#{sym}")
     end
@@ -59,6 +63,7 @@ module God
     protected
     
     def complain(text)
+      Syslog.err(text)
       puts text
       false
     end

data/lib/god/behaviors/clean_pid_file.rb

@@ -2,20 +2,14 @@ module God
   module Behaviors
     
     class CleanPidFile < Behavior
-      attr_accessor :pid_file
-    
-      def initialize
-        self.pid_file = nil
-      end
-  
       def valid?
         valid = true
-        valid &= complain("You must specify the 'pid_file' attribute for :clean_pid_file") if self.pid_file.nil?
+        valid &= complain("You must specify the 'pid_file' attribute on the Watch for :clean_pid_file") if self.watch.pid_file.nil?
         valid
       end
   
       def before_start
-        File.delete(self.pid_file) rescue nil
+        File.delete(self.watch.pid_file) rescue nil
       end
     end
   

data/lib/god/condition.rb

@@ -4,15 +4,16 @@ module God
     # Generate a Condition of the given kind. The proper class if found by camel casing the
     # kind (which is given as an underscored symbol).
     #   +kind+ is the underscored symbol representing the class (e.g. foo_bar for God::Conditions::FooBar)
-    def self.generate(kind)
+    def self.generate(kind, watch)
       sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
-      cond = God::Conditions.const_get(sym).new
+      c = God::Conditions.const_get(sym).new
       
-      unless cond.kind_of?(PollCondition) || cond.kind_of?(EventCondition)
-        abort "Condition '#{cond.class.name}' must subclass either God::PollCondition or God::EventCondition" 
+      unless c.kind_of?(PollCondition) || c.kind_of?(EventCondition)
+        abort "Condition '#{c.class.name}' must subclass either God::PollCondition or God::EventCondition" 
       end
       
-      cond
+      c.watch = watch
+      c
     rescue NameError
       raise NoSuchConditionError.new("No Condition found with the class name God::Conditions::#{sym}")
     end

data/lib/god/conditions/cpu_usage.rb

@@ -2,7 +2,7 @@ module God
   module Conditions
     
     class CpuUsage < PollCondition
-      attr_accessor :pid_file, :above, :times
+      attr_accessor :above, :times
     
       def initialize
         super
@@ -20,15 +20,15 @@ module God
     
       def valid?
         valid = true
-        valid &= complain("You must specify the 'pid_file' attribute for :memory_usage") if self.pid_file.nil?
+        valid &= complain("You must specify the 'pid_file' attribute on the Watch for :memory_usage") if self.watch.pid_file.nil?
         valid &= complain("You must specify the 'above' attribute for :memory_usage") if self.above.nil?
         valid
       end
     
       def test
-        return false unless File.exist?(self.pid_file)
+        return false unless File.exist?(self.watch.pid_file)
         
-        pid = File.open(self.pid_file).read.strip
+        pid = File.read(self.watch.pid_file).strip
         process = System::Process.new(pid)
         @timeline.push(process.percent_cpu)
         if @timeline.select { |x| x > self.above }.size >= self.times.first

data/lib/god/conditions/lambda.rb

@@ -0,0 +1,19 @@
+module God
+  module Conditions
+    
+    class Lambda < PollCondition
+      attr_accessor :lambda
+
+      def valid?
+        valid = true
+        valid &= complain("You must specify the 'lambda' attribute for :lambda") if self.lambda.nil?
+        valid
+      end
+
+      def test
+        self.lambda.call()
+      end
+    end
+
+  end
+end

data/lib/god/conditions/memory_usage.rb

@@ -2,7 +2,7 @@ module God
   module Conditions
     
     class MemoryUsage < PollCondition
-      attr_accessor :pid_file, :above, :times
+      attr_accessor :above, :times
     
       def initialize
         super
@@ -20,15 +20,15 @@ module God
     
       def valid?
         valid = true
-        valid &= complain("You must specify the 'pid_file' attribute for :memory_usage") if self.pid_file.nil?
+        valid &= complain("You must specify the 'pid_file' attribute on the Watch for :memory_usage") if self.watch.pid_file.nil?
         valid &= complain("You must specify the 'above' attribute for :memory_usage") if self.above.nil?
         valid
       end
     
       def test
-        return false unless File.exist?(self.pid_file)
+        return false unless File.exist?(self.watch.pid_file)
         
-        pid = File.open(self.pid_file).read.strip
+        pid = File.read(self.watch.pid_file).strip
         process = System::Process.new(pid)
         @timeline.push(process.memory)
         if @timeline.select { |x| x > self.above }.size >= self.times.first

data/lib/god/conditions/process_exits.rb

@@ -2,24 +2,22 @@ module God
   module Conditions
     
     class ProcessExits < EventCondition
-      attr_accessor :pid_file
-      
       def valid?
         valid = true
-        valid &= complain("You must specify the 'pid_file' attribute for :process_exits") if self.pid_file.nil?
+        valid &= complain("You must specify the 'pid_file' attribute on the Watch for :process_exits") if self.watch.pid_file.nil?
         valid
       end
     
       def register
-        pid = File.open(self.pid_file).read.strip.to_i
+        pid = File.read(self.watch.pid_file).strip.to_i
         
-        EventHandler.register(pid, :proc_exit) {
+        EventHandler.register(pid, :proc_exit) do
           Hub.trigger(self)
-        }
+        end
       end
       
       def deregister
-        pid = File.open(self.pid_file).read.strip.to_i
+        pid = File.read(self.watch.pid_file).strip.to_i
         EventHandler.deregister(pid, :proc_exit)
       end
     end

data/lib/god/conditions/process_running.rb

@@ -2,19 +2,19 @@ module God
   module Conditions
     
     class ProcessRunning < PollCondition
-      attr_accessor :pid_file, :running
+      attr_accessor :running
       
       def valid?
         valid = true
-        valid &= complain("You must specify the 'pid_file' attribute for :process_running") if self.pid_file.nil?
+        valid &= complain("You must specify the 'pid_file' attribute on the Watch for :process_running") if self.watch.pid_file.nil?
         valid &= complain("You must specify the 'running' attribute for :process_running") if self.running.nil?
         valid
       end
     
       def test
-        return !self.running unless File.exist?(self.pid_file)
+        return !self.running unless File.exist?(self.watch.pid_file)
         
-        pid = File.open(self.pid_file).read.strip
+        pid = File.read(self.watch.pid_file).strip
         active = System::Process.new(pid).exists?
         
         (self.running && active) || (!self.running && !active)