god 0.1.0

data/lib/god/conditions/cpu_usage.rb

@@ -0,0 +1,44 @@
+module God
+  module Conditions
+    
+    class CpuUsage < PollCondition
+      attr_accessor :pid_file, :above, :times
+    
+      def initialize
+        super
+        self.above = nil
+        self.times = [1, 1]
+      end
+      
+      def prepare
+        if self.times.kind_of?(Integer)
+          self.times = [self.times, self.times]
+        end
+        
+        @timeline = Timeline.new(self.times[1])
+      end
+    
+      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 'above' attribute for :memory_usage") if self.above.nil?
+        valid
+      end
+    
+      def test
+        return false unless File.exist?(self.pid_file)
+        
+        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
+          return true
+        else
+          @timeline.clear
+          return false
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/memory_usage.rb

@@ -0,0 +1,44 @@
+module God
+  module Conditions
+    
+    class MemoryUsage < PollCondition
+      attr_accessor :pid_file, :above, :times
+    
+      def initialize
+        super
+        self.above = nil
+        self.times = [1, 1]
+      end
+      
+      def prepare
+        if self.times.kind_of?(Integer)
+          self.times = [self.times, self.times]
+        end
+        
+        @timeline = Timeline.new(self.times[1])
+      end
+    
+      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 'above' attribute for :memory_usage") if self.above.nil?
+        valid
+      end
+    
+      def test
+        return false unless File.exist?(self.pid_file)
+        
+        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
+          return true
+        else
+          @timeline.clear
+          return false
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/process_not_running.rb

@@ -0,0 +1,22 @@
+module God
+  module Conditions
+    
+    class ProcessNotRunning < PollCondition
+      attr_accessor :pid_file
+      
+      def valid?
+        valid = true
+        valid &= complain("You must specify the 'pid_file' attribute for :process_not_running") if self.pid_file.nil?
+        valid
+      end
+    
+      def test
+        return false unless File.exist?(self.pid_file)
+        
+        pid = File.open(self.pid_file).read.strip
+        System::Process.new(pid).exists?
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/timeline.rb

@@ -0,0 +1,17 @@
+module God
+  module Conditions
+    
+    class Timeline < Array
+      def initialize(max_size)
+        super()
+        @max_size = max_size
+      end
+      
+      def push(val)
+        unshift(val)
+        pop if size > @max_size
+      end
+    end
+    
+  end
+end

data/lib/god/errors.rb

@@ -0,0 +1,12 @@
+module God
+  
+  class AbstractMethodNotOverriddenError < StandardError
+  end
+  
+  class NoSuchConditionError < StandardError
+  end
+  
+  class NoSuchBehaviorError < StandardError
+  end
+  
+end

data/lib/god/meddle.rb

@@ -0,0 +1,54 @@
+module God
+  
+  class Meddle < Base
+    # drb
+    attr_accessor :server
+    
+    # api
+    attr_accessor :watches, :timer
+    
+    # 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
+    # block. The attributes of the watch will be set by the configuration
+    # file.
+    def watch
+      w = Watch.new(self)
+      yield(w)
+      
+      # ensure the new watch has a unique name
+      unless @watches.select { |x| x.name == w.name }.empty?
+        abort "Duplicate Watch with name '#{w.name}'"
+      end
+      
+      # add to list of watches
+      @watches << w
+    end
+    
+    # Schedule all poll conditions and register all condition events
+    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/reporter.rb

@@ -0,0 +1,25 @@
+require 'drb'
+
+module God
+
+  class Reporter
+    def initialize(host = nil, port = nil)
+      @host = host
+      @port = port || 7777
+      @service = nil
+    end
+
+    def method_missing(*args, &block)
+      service.send(*args, &block)
+    end
+
+    private
+
+    def service
+      return @service if @service
+      DRb.start_service
+      @service = DRbObject.new(nil, "druby://#{@host}:#{@port}")
+    end
+  end
+
+end

data/lib/god/server.rb

@@ -0,0 +1,28 @@
+require 'drb'
+
+# The God::Server oversees the DRb server which dishes out info on this God daemon.
+
+module God
+
+  class Server
+    attr_reader :host, :port
+
+    def initialize(meddle = nil, host = nil, port = nil)
+      @meddle = meddle
+      @host = host
+      @port = port || 7777
+      start
+    end
+
+    def method_missing(*args, &block)
+      @meddle.send(*args, &block)
+    end
+
+    private
+
+    def start
+      @drb ||= DRb.start_service("druby://#{@host}:#{@port}", self) 
+    end
+  end
+
+end

data/lib/god/system/process.rb

@@ -0,0 +1,56 @@
+module God
+  module System
+  
+    class Process
+      def initialize(pid)
+        @pid = pid.to_i
+      end
+      
+      # Return true if this process is running, false otherwise
+      def exists?
+        cmd_name = RUBY_PLATFORM =~ /solaris/i ? "args" : "command"
+        !ps_string(cmd_name).empty?
+      end
+      
+      # Memory usage in kilobytes (resident set size)
+      def memory
+        ps_int('rss')
+      end
+      
+      # Percentage memory usage
+      def percent_memory
+        ps_float('%mem')
+      end
+      
+      # Percentage CPU usage
+      def percent_cpu
+        ps_float('%cpu')
+      end
+      
+      # Seconds of CPU time (accumulated cpu time, user + system)
+      def cpu_time
+        time_string_to_seconds(ps_string('time'))
+      end
+      
+      private
+      
+      def ps_int(keyword)
+        `ps -o #{keyword}= -p #{@pid}`.to_i
+      end
+      
+      def ps_float(keyword)
+        `ps -o #{keyword}= -p #{@pid}`.to_f
+      end
+      
+      def ps_string(keyword)
+        `ps -o #{keyword}= -p #{@pid}`.strip
+      end
+      
+      def time_string_to_seconds(text)
+        _, minutes, seconds, useconds = *text.match(/(\d+):(\d{2}).(\d{2})/)
+        (minutes.to_i * 60) + seconds.to_i
+      end
+    end
+  
+  end
+end

data/lib/god/timer.rb

@@ -0,0 +1,78 @@
+module God
+  
+  class TimerEvent
+    attr_accessor :watch, :condition, :command, :at
+    
+    def initialize(watch, condition, command)
+      self.watch = watch
+      self.condition = condition
+      self.command = command
+      self.at = Time.now.to_i + condition.interval
+    end
+  end
+  
+  class Timer < Base
+    INTERVAL = 0.25
+    
+    attr_reader :events
+    
+    # Start the scheduler loop to handle events
+    def initialize
+      @events = []
+      
+      @timer = Thread.new do
+        loop do
+          # get the current time
+          t = Time.now.to_i
+          
+          # iterate over each event and trigger any that are due
+          @events.each do |event|
+            if t >= event.at
+              self.trigger(event)
+              @events.delete(event)
+            else
+              break
+            end
+          end
+          
+          # sleep until next check
+          sleep INTERVAL
+        end
+      end
+    end
+    
+    # Create and register a new TimerEvent with the given parameters
+    def register(watch, condition, command)
+      @events << TimerEvent.new(watch, condition, command)
+      @events.sort! { |x, y| x.at <=> y.at }
+    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
+    end
+    
+    # Join the timer thread
+    def join
+      @timer.join
+    end
+  end
+  
+end

data/lib/god/watch.rb

@@ -0,0 +1,151 @@
+module God
+  
+  class Watch < Base
+    # config
+    attr_accessor :name, :start, :stop, :restart, :interval, :grace
+    
+    # api
+    attr_accessor :behaviors, :conditions
+    
+    # internal
+    attr_accessor :mutex
+    
+    # 
+    def initialize(meddle)
+      @meddle = meddle
+      
+      # no grace period by default
+      self.grace = 0
+      
+      # keep track of which action each condition belongs to
+      @action = nil
+      
+      self.behaviors = []
+      
+      # the list of conditions for each action
+      self.conditions = {:start => [],
+                         :restart => []}
+                         
+      # mutex
+      self.mutex = Mutex.new
+    end
+    
+    def behavior(kind)
+      # create the behavior
+      begin
+        b = Behavior.generate(kind)
+      rescue NoSuchBehaviorError => e
+        abort e.message
+      end
+      
+      # send to block so config can set attributes
+      yield(b) if block_given?
+      
+      # abort if the Behavior is invalid, the Behavior will have printed
+      # out its own error messages by now
+      abort unless b.valid?
+      
+      self.behaviors << b
+    end
+    
+    def start_if
+      @action = :start
+      yield(self)
+      @action = nil
+    end
+    
+    def restart_if
+      @action = :restart
+      yield(self)
+      @action = nil
+    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)
+      # must be in a _if block
+      unless @action
+        abort "Watch#condition can only be called from inside a start_if block"
+      end
+      
+      # 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.interval
+          c.interval = self.interval
+        else
+          abort "No interval set for Condition '#{c.class.name}' in Watch '#{self.name}', and no default Watch interval from which to inherit"
+        end
+      end
+      
+      self.conditions[@action] << c
+    end
+        
+    # Schedule all poll conditions and register all condition events
+    def monitor
+      [:start, :restart].each do |cmd|
+        self.conditions[cmd].each do |c|
+          @meddle.timer.register(self, c, cmd) if c.kind_of?(PollCondition)
+        end
+      end
+    end
+    
+    def action(a, c)
+      case a
+      when :start
+        puts self.start
+        call_action(c, :start, self.start)
+        sleep(self.grace)
+      when :restart
+        if self.restart
+          puts self.restart
+          call_action(c, :restart, self.restart)
+        else
+          action(:stop, c)
+          action(:start, c)
+        end
+        sleep(self.grace)
+      when :stop
+        puts self.stop
+        call_action(c, :stop, self.stop)
+        sleep(self.grace)
+      end      
+    end
+    
+    def call_action(condition, action, command)
+      # before
+      (self.behaviors + [condition]).each { |b| b.send("before_#{action}") }
+      
+      # action
+      if command.kind_of?(String)
+        # string command
+        system(command)
+      else
+        # lambda command
+        command.call
+      end
+      
+      # after
+      (self.behaviors + [condition]).each { |b| b.send("after_#{action}") }
+    end
+  end
+  
+end