god 0.1.0 → 0.2.0

data/lib/god.rb

@@ -11,7 +11,8 @@ require 'god/behaviors/clean_pid_file'
 
 require 'god/condition'
 require 'god/conditions/timeline'
-require 'god/conditions/process_not_running'
+require 'god/conditions/process_running'
+require 'god/conditions/process_exits'
 require 'god/conditions/memory_usage'
 require 'god/conditions/cpu_usage'
 require 'god/conditions/always'
@@ -19,17 +20,49 @@ require 'god/conditions/always'
 require 'god/reporter'
 require 'god/server'
 require 'god/timer'
+require 'god/hub'
+
+require 'god/metric'
 
 require 'god/watch'
 require 'god/meddle'
 
+require 'god/event_handler'
+
+Thread.abort_on_exception = true
+
 module God
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
   
-  def self.meddle(options = {})
+  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"
+  end
+  
+  def self.meddle(options = {})  
     m = Meddle.new(options)
+    
+    # yeild to the config file
     yield m
+    
+    # start event handler system
+    EventHandler.start
+    
+    # start the timer system
+    Timer.get
+
+    # start monitoring each watch
     m.monitor
-    m.timer.join
+    
+    # join the timer thread to we don't exit
+    Timer.get.join
   end  
 end

data/lib/god/conditions/always.rb

@@ -2,8 +2,16 @@ module God
   module Conditions
 
     class Always < PollCondition
+      attr_accessor :what
+      
+      def valid?
+        valid = true
+        valid &= complain("You must specify the 'what' attribute for :always") if self.what.nil?
+        valid
+      end
+      
       def test
-        false
+        @what
       end
     end
   

data/lib/god/conditions/cpu_usage.rb

@@ -31,10 +31,10 @@ module God
         pid = File.open(self.pid_file).read.strip
         process = System::Process.new(pid)
         @timeline.push(process.percent_cpu)
-        if @timeline.select { |x| x > self.above }.size < self.times.first
+        if @timeline.select { |x| x > self.above }.size >= self.times.first
+          @timeline.clear
           return true
         else
-          @timeline.clear
           return false
         end
       end

data/lib/god/conditions/memory_usage.rb

@@ -31,10 +31,10 @@ module God
         pid = File.open(self.pid_file).read.strip
         process = System::Process.new(pid)
         @timeline.push(process.memory)
-        if @timeline.select { |x| x > self.above }.size < self.times.first
+        if @timeline.select { |x| x > self.above }.size >= self.times.first
+          @timeline.clear
           return true
         else
-          @timeline.clear
           return false
         end
       end

data/lib/god/conditions/process_exits.rb

@@ -0,0 +1,28 @@
+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
+      end
+    
+      def register
+        pid = File.open(self.pid_file).read.strip.to_i
+        
+        EventHandler.register(pid, :proc_exit) {
+          Hub.trigger(self)
+        }
+      end
+      
+      def deregister
+        pid = File.open(self.pid_file).read.strip.to_i
+        EventHandler.deregister(pid, :proc_exit)
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/process_running.rb

@@ -0,0 +1,25 @@
+module God
+  module Conditions
+    
+    class ProcessRunning < PollCondition
+      attr_accessor :pid_file, :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 'running' attribute for :process_running") if self.running.nil?
+        valid
+      end
+    
+      def test
+        return !self.running unless File.exist?(self.pid_file)
+        
+        pid = File.open(self.pid_file).read.strip
+        active = System::Process.new(pid).exists?
+        
+        (self.running && active) || (!self.running && !active)
+      end
+    end
+    
+  end
+end

data/lib/god/event_handler.rb

@@ -0,0 +1,45 @@
+module God
+  class EventHandler
+    @@actions = {}
+    @@handler = nil
+    
+    def self.handler=(value)
+      @@handler = value
+    end
+    
+    def self.register(pid, event, &block)
+      @@actions[pid] ||= {}
+      @@actions[pid][event] = block
+      @@handler.register_process(pid, @@actions[pid].keys)
+    end
+    
+    def self.deregister(pid, event=nil)
+      if watching_pid? pid
+        if event.nil?
+          @@actions.delete(pid)
+          @@handler.register_process(pid, []) if system("kill -0 #{pid} &> /dev/null")
+        else
+          @@actions[pid].delete(event)
+          @@handler.register_process(pid, @@actions[pid].keys) if system("kill -0 #{pid} &> /dev/null")
+        end
+      end
+    end
+    
+    def self.call(pid, event)
+      @@actions[pid][event].call
+    end
+    
+    def self.watching_pid?(pid)
+      @@actions[pid]
+    end
+    
+    def self.start
+      Thread.new do
+        loop do
+          @@handler.handle_events
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/event_handlers/kqueue_handler.rb

@@ -0,0 +1,15 @@
+require 'kqueue_handler_ext'
+
+module God
+  class KQueueHandler
+    def self.register_process(pid, events)
+      monitor_process(pid, events_mask(events))
+    end
+  
+    def self.events_mask(events)
+      events.inject(0) do |mask, event|
+        mask |= event_mask(event)
+      end
+    end
+  end
+end

data/lib/god/event_handlers/netlink_handler.rb

@@ -0,0 +1,11 @@
+require 'netlink_handler_ext'
+
+module God
+  class NetlinkHandler
+    def self.register_process(pid, events)
+      # netlink doesn't need to do this
+      # it just reads from the eventhandler actions to see if the pid
+      # matches the list we're looking for -- Kev
+    end
+  end
+end

data/lib/god/hub.rb

@@ -0,0 +1,84 @@
+module God
+  
+  class Hub
+    # directory to hold conditions and their corresponding metric
+    #   key: condition
+    #   val: metric
+    @@directory = {}
+    
+    def self.attach(condition, metric)
+      # add the condition to the directory
+      @@directory[condition] = metric
+      
+      # schedule poll condition
+      # register event condition
+      if condition.kind_of?(PollCondition)
+        Timer.get.schedule(condition, 0)
+      else
+        condition.register
+      end
+    end
+    
+    def self.detach(condition)
+      # remove the condition from the directory
+      @@directory.delete(condition)
+      
+      # unschedule any pending polls
+      Timer.get.unschedule(condition)
+      
+      # deregister event condition
+      if condition.kind_of?(EventCondition)
+        condition.deregister
+      end
+    end
+    
+    def self.trigger(condition)
+      if condition.kind_of?(PollCondition)
+        self.handle_poll(condition)
+      elsif condition.kind_of?(EventCondition)
+        self.handle_event(condition)
+      end
+    end
+    
+    def self.handle_poll(condition)
+      Thread.new do
+        metric = @@directory[condition]
+        watch = metric.watch
+        
+        watch.mutex.synchronize do
+          result = condition.test
+          
+          puts watch.name + ' ' + condition.class.name + " [#{result}]"
+          
+          condition.after
+          
+          p metric.destination
+          
+          if dest = metric.destination[result]
+            watch.move(dest)
+          else
+            # reschedule
+            Timer.get.schedule(condition)
+          end
+        end
+      end
+    end
+    
+    def self.handle_event(condition)
+      Thread.new do
+        metric = @@directory[condition]
+        watch = metric.watch
+        
+        watch.mutex.synchronize do
+          puts watch.name + ' ' + condition.class.name + " [true]"
+          
+          p metric.destination
+          
+          dest = metric.destination[true]
+          watch.move(dest)
+        end
+      end
+    end
+  end
+  
+end

data/lib/god/meddle.rb

@@ -5,13 +5,12 @@ module God
     attr_accessor :server
     
     # api
-    attr_accessor :watches, :timer
+    attr_accessor :watches
     
     # Create a new instance that is ready for use by a configuration file
     def initialize(options = {})
       self.watches = []
       self.server  = Server.new(self, options[:host], options[:port])
-      self.timer = Timer.new
     end
       
     # Instantiate a new, empty Watch object and pass it to the mandatory
@@ -34,21 +33,6 @@ module God
     def monitor
       @watches.each { |w| w.monitor }
     end
-    
-    # def monitor
-    #   threads = []
-    #   
-    #   @watches.each do |w|
-    #     threads << Thread.new do
-    #       while true do
-    #         w.run
-    #         sleep self.interval
-    #       end
-    #     end
-    #   end
-    #   
-    #   threads.each { |t| t.join }
-    # end
   end
   
 end

data/lib/god/metric.rb

@@ -0,0 +1,60 @@
+module God
+  
+  class Metric < Base
+    attr_accessor :watch, :destination, :conditions
+    
+    def initialize(watch, destination)
+      self.watch = watch
+      self.destination = destination
+      self.conditions = []
+    end
+    
+    # Instantiate a Condition of type +kind+ and pass it into the optional
+    # block. Attributes of the condition must be set in the config file
+    def condition(kind)
+      # create the condition
+      begin
+        c = Condition.generate(kind)
+      rescue NoSuchConditionError => e
+        abort e.message
+      end
+      
+      # send to block so config can set attributes
+      yield(c) if block_given?
+      
+      # call prepare on the condition
+      c.prepare
+      
+      # abort if the Condition is invalid, the Condition will have printed
+      # out its own error messages by now
+      unless c.valid?
+        abort
+      end
+      
+      # inherit interval from meddle if no poll condition specific interval was set
+      if c.kind_of?(PollCondition) && !c.interval
+        if self.watch.interval
+          c.interval = self.watch.interval
+        else
+          abort "No interval set for Condition '#{c.class.name}' in Watch '#{self.watch.name}', and no default Watch interval from which to inherit"
+        end
+      end
+      
+      # remember
+      self.conditions << c
+    end
+    
+    def enable
+      self.conditions.each do |c|
+        Hub.attach(c, self)
+      end
+    end
+    
+    def disable
+      self.conditions.each do |c|
+        Hub.detach(c)
+      end
+    end
+  end
+  
+end

data/lib/god/timer.rb

@@ -1,13 +1,11 @@
 module God
   
   class TimerEvent
-    attr_accessor :watch, :condition, :command, :at
+    attr_accessor :condition, :at
     
-    def initialize(watch, condition, command)
-      self.watch = watch
+    def initialize(condition, interval)
       self.condition = condition
-      self.command = command
-      self.at = Time.now.to_i + condition.interval
+      self.at = Time.now.to_i + interval
     end
   end
   
@@ -16,6 +14,16 @@ module God
     
     attr_reader :events
     
+    @@timer = nil
+    
+    def self.get
+      @@timer ||= Timer.new
+    end
+    
+    def self.reset
+      @@timer = nil
+    end
+    
     # Start the scheduler loop to handle events
     def initialize
       @events = []
@@ -42,31 +50,18 @@ module God
     end
     
     # Create and register a new TimerEvent with the given parameters
-    def register(watch, condition, command)
-      @events << TimerEvent.new(watch, condition, command)
+    def schedule(condition, interval = condition.interval)
+      @events << TimerEvent.new(condition, interval)
       @events.sort! { |x, y| x.at <=> y.at }
     end
     
+    # Remove any TimerEvents for the given condition
+    def unschedule(condition)
+      @events.reject! { |x| x.condition == condition }
+    end
+    
     def trigger(event)
-      timer = self
-      
-      Thread.new do
-        w = event.watch
-        c = event.condition
-        
-        w.mutex.synchronize do
-          if c.test
-            puts w.name + ' ' + c.class.name + ' [ok]'
-          else
-            puts w.name + ' ' + c.class.name + ' [fail]'
-            c.after
-            w.action(event.command, c)
-          end
-        end
-        
-        # reschedule
-        timer.register(w, c, event.command)
-      end
+      Hub.trigger(event.condition)
     end
     
     # Join the timer thread