god 0.2.0 → 0.3.0

data/lib/god/errors.rb

@@ -9,4 +9,7 @@ module God
   class NoSuchBehaviorError < StandardError
   end
   
+  class InvalidCommandError < StandardError
+  end
+  
 end

data/lib/god/event_handler.rb

@@ -2,9 +2,34 @@ module God
   class EventHandler
     @@actions = {}
     @@handler = nil
+    @@loaded = false
     
-    def self.handler=(value)
-      @@handler = value
+    def self.loaded?
+      @@loaded
+    end
+    
+    def self.event_system
+      @@handler::EVENT_SYSTEM
+    end
+    
+    def self.load
+      begin
+        case RUBY_PLATFORM
+        when /darwin/i, /bsd/i
+          require 'god/event_handlers/kqueue_handler'
+          @@handler = KQueueHandler
+        when /linux/i
+          require 'god/event_handlers/netlink_handler'
+          @@handler = NetlinkHandler
+        else
+          raise NotImplementedError, "Platform not supported for EventHandler"
+        end
+        @@loaded = true
+      rescue Exception
+        require 'god/event_handlers/dummy_handler'
+        @@handler = DummyHandler
+        @@loaded = false
+      end
     end
     
     def self.register(pid, event, &block)
@@ -26,7 +51,7 @@ module God
     end
     
     def self.call(pid, event)
-      @@actions[pid][event].call
+      @@actions[pid][event].call if watching_pid?(pid) && @@actions[pid][event]
     end
     
     def self.watching_pid?(pid)

data/lib/god/event_handlers/dummy_handler.rb

@@ -0,0 +1,13 @@
+module God
+  class DummyHandler
+    EVENT_SYSTEM = "none"
+    
+    def self.register_process
+      raise NotImplementedError
+    end
+    
+    def self.handle_events
+      raise NotImplementedError
+    end
+  end
+end

data/lib/god/event_handlers/kqueue_handler.rb

@@ -2,6 +2,8 @@ require 'kqueue_handler_ext'
 
 module God
   class KQueueHandler
+    EVENT_SYSTEM = "kqueue"
+    
     def self.register_process(pid, events)
       monitor_process(pid, events_mask(events))
     end

data/lib/god/event_handlers/netlink_handler.rb

@@ -2,6 +2,8 @@ require 'netlink_handler_ext'
 
 module God
   class NetlinkHandler
+    EVENT_SYSTEM = "netlink"
+    
     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

data/lib/god/hub.rb

@@ -1,14 +1,18 @@
 module God
   
   class Hub
-    # directory to hold conditions and their corresponding metric
-    #   key: condition
-    #   val: metric
-    @@directory = {}
+    class << self
+      # directory to hold conditions and their corresponding metric
+      #   key: condition
+      #   val: metric
+      attr_accessor :directory
+    end
+    
+    self.directory = {}
     
     def self.attach(condition, metric)
       # add the condition to the directory
-      @@directory[condition] = metric
+      self.directory[condition] = metric
       
       # schedule poll condition
       # register event condition
@@ -21,7 +25,7 @@ module God
     
     def self.detach(condition)
       # remove the condition from the directory
-      @@directory.delete(condition)
+      self.directory.delete(condition)
       
       # unschedule any pending polls
       Timer.get.unschedule(condition)
@@ -42,37 +46,50 @@ module God
     
     def self.handle_poll(condition)
       Thread.new do
-        metric = @@directory[condition]
-        watch = metric.watch
-        
-        watch.mutex.synchronize do
-          result = condition.test
+        begin
+          metric = self.directory[condition]
+          
+          # it's possible that the timer will trigger an event before it can be cleared
+          # by an exiting metric, in which case it should be ignored
+          return if metric.nil?
           
-          puts watch.name + ' ' + condition.class.name + " [#{result}]"
+          watch = metric.watch
+        
+          watch.mutex.synchronize do
+            result = condition.test
           
-          condition.after
+            msg = watch.name + ' ' + condition.class.name + " [#{result}] " + metric.destination.inspect
+            Syslog.debug(msg)
+            puts msg
           
-          p metric.destination
+            condition.after
           
-          if dest = metric.destination[result]
-            watch.move(dest)
-          else
-            # reschedule
-            Timer.get.schedule(condition)
+            dest = metric.destination[result]
+            if dest
+              watch.move(dest)
+            else
+              # reschedule
+              Timer.get.schedule(condition)
+            end
           end
+        rescue => e
+          message = format("Unhandled exception (%s): %s\n%s",
+                           e.class, e.message, e.backtrace.join("\n"))
+          Syslog.crit message
+          abort message
         end
       end
     end
     
     def self.handle_event(condition)
       Thread.new do
-        metric = @@directory[condition]
+        metric = self.directory[condition]
         watch = metric.watch
         
         watch.mutex.synchronize do
-          puts watch.name + ' ' + condition.class.name + " [true]"
-          
-          p metric.destination
+          msg = watch.name + ' ' + condition.class.name + " [true] " + metric.destination.inspect
+          Syslog.debug(msg)
+          puts msg
           
           dest = metric.destination[true]
           watch.move(dest)

data/lib/god/metric.rb

@@ -1,6 +1,6 @@
 module God
   
-  class Metric < Base
+  class Metric
     attr_accessor :watch, :destination, :conditions
     
     def initialize(watch, destination)
@@ -14,7 +14,7 @@ module God
     def condition(kind)
       # create the condition
       begin
-        c = Condition.generate(kind)
+        c = Condition.generate(kind, self.watch)
       rescue NoSuchConditionError => e
         abort e.message
       end
@@ -28,10 +28,10 @@ module God
       # abort if the Condition is invalid, the Condition will have printed
       # out its own error messages by now
       unless c.valid?
-        abort
+        abort "Exiting on invalid condition"
       end
       
-      # inherit interval from meddle if no poll condition specific interval was set
+      # inherit interval from watch if no poll condition specific interval was set
       if c.kind_of?(PollCondition) && !c.interval
         if self.watch.interval
           c.interval = self.watch.interval

data/lib/god/process.rb

@@ -0,0 +1,105 @@
+require 'fileutils'
+
+module God
+  class Process
+    WRITES_PID = [:start, :restart]
+    
+    attr_accessor :name, :uid, :gid, :start, :stop, :restart
+    
+    def initialize(options={})
+      options.each do |k,v|
+        send("#{k}=", v)
+      end
+      
+      @tracking_pid = false
+    end
+    
+    # DON'T USE THIS INTERNALLY. Use the instance variable. -- Kev
+    # No really, trust me. Use the instance variable.
+    def pid_file=(value)
+      @tracking_pid = false
+      @pid_file = value
+    end
+    
+    def pid_file
+      if @pid_file.nil?
+        @tracking_pid = true
+        @pid_file = default_pid_file
+      end
+      @pid_file
+    end
+    
+    def start!
+      call_action(:start)
+    end
+    
+    def stop!
+      call_action(:stop)
+    end
+    
+    def restart!
+      call_action(:restart)
+    end
+    
+    def call_action(action)
+      command = send(action)
+      if command.kind_of?(String)
+        # Make pid directory
+        unless test(?d, God.pid_file_directory)
+          begin
+            FileUtils.mkdir_p(God.pid_file_directory)
+          rescue Errno::EACCES => e
+            abort"Failed to create pid file directory: #{e.message}"
+          end
+        end
+        
+        unless test(?w, God.pid_file_directory)
+          abort "The pid file directory (#{God.pid_file_directory}) is not writable by #{Etc.getlogin}"
+        end
+        
+        # string command
+        # fork/exec to setuid/gid
+        r, w = IO.pipe
+        opid = fork do
+          STDOUT.reopen(w)
+          r.close
+          pid = fork do
+            ::Process.setsid
+            ::Process::Sys.setgid(Etc.getgrnam(self.gid).gid) if self.gid
+            ::Process::Sys.setuid(Etc.getpwnam(self.uid).uid) if self.uid
+            Dir.chdir "/"
+            $0 = command
+            STDIN.reopen "/dev/null"
+            STDOUT.reopen "/dev/null", "a"
+            STDERR.reopen STDOUT
+            exec command
+          end
+          puts pid.to_s
+        end
+        
+        ::Process.waitpid(opid, 0)
+        w.close
+        pid = r.gets.chomp
+        
+        if @tracking_pid or (@pid_file.nil? and WRITES_PID.include?(action))
+          File.open(default_pid_file, 'w') do |f|
+            f.write pid
+          end
+          
+          @tracking_pid = true
+          @pid_file = default_pid_file
+        end
+        
+      elsif command.kind_of?(Proc)
+        # lambda command
+        command.call
+      else
+        raise NotImplementedError
+      end
+    end
+    
+    def default_pid_file
+      File.join(God.pid_file_directory, "#{self.name}.pid")
+    end
+  end
+end

data/lib/god/registry.rb

@@ -0,0 +1,28 @@
+module God
+  def self.registry
+    @registry ||= Registry.new
+  end
+  
+  class Registry
+    def initialize
+      @storage = {}
+    end
+    
+    def add(item)
+      # raise TypeError unless item.is_a? God::Process
+      @storage[item.name] = item
+    end
+    
+    def size
+      @storage.size
+    end
+    
+    def [](name)
+      @storage[name]
+    end
+    
+    def reset
+      @storage.clear
+    end
+  end
+end

data/lib/god/server.rb

@@ -7,15 +7,14 @@ module God
   class Server
     attr_reader :host, :port
 
-    def initialize(meddle = nil, host = nil, port = nil)
-      @meddle = meddle
+    def initialize(host = nil, port = nil)
       @host = host
-      @port = port || 7777
+      @port = port || 17165
       start
     end
 
     def method_missing(*args, &block)
-      @meddle.send(*args, &block)
+      God.send(*args, &block)
     end
 
     private

data/lib/god/sugar.rb

@@ -0,0 +1,47 @@
+class Numeric
+  def seconds
+    self
+  end
+  
+  alias :second :seconds
+  
+  def minutes
+    self * 60
+  end
+  
+  alias :minute :minutes
+  
+  def hours
+    self * 3600
+  end
+  
+  alias :hour :hours
+  
+  def days
+    self * 86400
+  end
+  
+  alias :day :days
+  
+  def kilobytes
+    self
+  end
+  
+  alias :kilobyte :kilobytes
+  
+  def megabytes
+    self * 1024
+  end
+  
+  alias :megabyte :megabytes
+  
+  def gigabytes
+    self * (1024 ** 2)
+  end
+  
+  alias :gigabyte :gigabytes
+  
+  def percent
+    self
+  end
+end

data/lib/god/system/process.rb

@@ -8,8 +8,7 @@ module God
       
       # Return true if this process is running, false otherwise
       def exists?
-        cmd_name = RUBY_PLATFORM =~ /solaris/i ? "args" : "command"
-        !ps_string(cmd_name).empty?
+        system("kill -0 #{@pid} &> /dev/null")
       end
       
       # Memory usage in kilobytes (resident set size)

data/lib/god/timer.rb

@@ -9,10 +9,10 @@ module God
     end
   end
   
-  class Timer < Base
+  class Timer
     INTERVAL = 0.25
     
-    attr_reader :events
+    attr_reader :events, :timer
     
     @@timer = nil
     
@@ -27,6 +27,7 @@ module God
     # Start the scheduler loop to handle events
     def initialize
       @events = []
+      @mutex = Mutex.new
       
       @timer = Thread.new do
         loop do
@@ -37,7 +38,9 @@ module God
           @events.each do |event|
             if t >= event.at
               self.trigger(event)
-              @events.delete(event)
+              @mutex.synchronize do
+                @events.delete(event)
+              end
             else
               break
             end
@@ -51,13 +54,17 @@ module God
     
     # Create and register a new TimerEvent with the given parameters
     def schedule(condition, interval = condition.interval)
-      @events << TimerEvent.new(condition, interval)
-      @events.sort! { |x, y| x.at <=> y.at }
+      @mutex.synchronize do
+        @events << TimerEvent.new(condition, interval)
+        @events.sort! { |x, y| x.at <=> y.at }
+      end
     end
     
     # Remove any TimerEvents for the given condition
     def unschedule(condition)
-      @events.reject! { |x| x.condition == condition }
+      @mutex.synchronize do
+        @events.reject! { |x| x.condition == condition }
+      end
     end
     
     def trigger(event)