god 0.2.0 → 0.3.0

data/lib/god/watch.rb

@@ -1,10 +1,23 @@
+require 'etc'
+require 'forwardable'
+
 module God
   
-  class Watch < Base
+  class Watch
     VALID_STATES = [:init, :up, :start, :restart]
     
     # config
-    attr_accessor :name, :state, :start, :stop, :restart, :interval, :grace
+    attr_accessor :state, :interval, :group,
+                  :grace, :start_grace, :stop_grace, :restart_grace
+                  
+    
+    attr_writer   :autostart
+    def autostart?; @autostart; end
+    
+    extend Forwardable
+    def_delegators :@process, :name, :uid, :gid, :start, :stop, :restart,
+                              :name=, :uid=, :gid=, :start=, :stop=, :restart=,
+                              :pid_file, :pid_file=
     
     # api
     attr_accessor :behaviors, :metrics
@@ -13,11 +26,12 @@ module God
     attr_accessor :mutex
     
     # 
-    def initialize(meddle)
-      @meddle = meddle
+    def initialize
+      @autostart ||= true
+      @process = God::Process.new
             
       # no grace period by default
-      self.grace = 0
+      self.grace = self.start_grace = self.stop_grace = self.restart_grace = 0
       
       # the list of behaviors
       self.behaviors = []
@@ -35,7 +49,7 @@ module God
     def behavior(kind)
       # create the behavior
       begin
-        b = Behavior.generate(kind)
+        b = Behavior.generate(kind, self)
       rescue NoSuchBehaviorError => e
         abort e.message
       end
@@ -103,7 +117,7 @@ module God
     #
     ###########################################################################
         
-    # Schedule all poll conditions and register all condition events
+    # Enable monitoring
     def monitor
       # start monitoring at the first available of the init or up states
       if !self.metrics[:init].empty?
@@ -113,62 +127,76 @@ module God
       end
     end
     
+    # Disable monitoring
+    def unmonitor
+      self.move(nil)
+    end
+    
     # Move from one state to another
     def move(to_state)
-      puts "move '#{self.state}' to '#{to_state}'"
+      msg = "#{self.name} move '#{self.state}' to '#{to_state}'"
+      Syslog.debug(msg)
+      puts msg
        
       # cleanup from current state
-      if from_state = self.state
+      from_state = self.state
+      if from_state
         self.metrics[from_state].each { |m| m.disable }
       end
       
-      # perform action (if available)
+      # perform action
       self.action(to_state)
       
+      # enable simple mode
+      if [:start, :restart].include?(to_state) && self.metrics[to_state].empty?
+        to_state = :up
+      end
+      
       # move to new state
-      self.metrics[to_state].each { |m| m.enable }
+      if to_state
+        self.metrics[to_state].each { |m| m.enable }
+      end
       
       # set state
       self.state = to_state
+      
+      # return self
+      self
     end
     
     def action(a, c = nil)
       case a
       when :start
-        puts self.start
-        call_action(c, :start, self.start)
-        sleep(self.grace)
+        Syslog.debug(self.start.to_s)
+        puts self.start.to_s
+        call_action(c, :start)
+        sleep(self.start_grace + self.grace)
       when :restart
         if self.restart
+          Syslog.debug(self.restart.to_s)
           puts self.restart
-          call_action(c, :restart, self.restart)
+          call_action(c, :restart)
         else
           action(:stop, c)
           action(:start, c)
         end
-        sleep(self.grace)
+        sleep(self.restart_grace + self.grace)
       when :stop
-        puts self.stop
-        call_action(c, :stop, self.stop)
-        sleep(self.grace)
+        Syslog.debug(self.stop.to_s)
+        puts self.stop.to_s
+        call_action(c, :stop)
+        sleep(self.stop_grace + self.grace)
       end      
     end
     
-    def call_action(condition, action, command)
+    def call_action(condition, action)
       # before
       before_items = self.behaviors
       before_items += [condition] if condition
       before_items.each { |b| b.send("before_#{action}") }
       
-      # action
-      if command.kind_of?(String)
-        # string command
-        system(command)
-      else
-        # lambda command
-        command.call
-      end
-      
+      @process.call_action(action)
+
       # after
       after_items = self.behaviors
       after_items += [condition] if condition
@@ -178,6 +206,10 @@ module God
     def canonical_hash_form(to)
       to.instance_of?(Symbol) ? {true => to} : to
     end
+    
+    def register!
+      God.registry.add(@process)
+    end
   end
   
 end

data/test/configs/child_events/child_events.god

@@ -0,0 +1,25 @@
+God.watch do |w|
+  w.name = "child-events"
+  w.interval = 5.seconds
+  w.start = File.join(File.dirname(__FILE__), *%w[simple_server.rb])
+  w.stop = ""
+  
+  # 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, :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
+end

data/test/configs/child_events/simple_server.rb

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+
+loop { puts 'server'; sleep 1 }

data/test/configs/child_polls/child_polls.god

@@ -0,0 +1,15 @@
+God.watch do |w|
+  w.name = 'child-polls'
+  w.start = File.join(File.dirname(__FILE__), *%w[simple_server.rb])
+  w.stop = ''
+  w.interval = 5
+  w.grace = 2
+  w.uid = 'tom'
+  w.gid = 'tom'
+  
+  w.start_if do |start|
+    start.condition(:process_running) do |c|
+      c.running = false
+    end
+  end
+end

data/test/configs/child_polls/simple_server.rb

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+
+loop { puts 'server'; sleep 1 }

data/test/configs/daemon_events/daemon_events.god

@@ -0,0 +1,30 @@
+God.watch do |w|
+  w.name = "daemon-events"
+  w.interval = 5.seconds
+  w.start = '/usr/local/bin/ruby ' + File.join(File.dirname(__FILE__), *%w[simple_server.rb]) + ' start'
+  w.stop = '/usr/local/bin/ruby ' + File.join(File.dirname(__FILE__), *%w[simple_server.rb]) + ' stop'
+  w.uid = 'tom'
+  w.gid = 'tom'
+  w.pid_file = '/var/run/daemon-events.pid'
+  
+  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, :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
+end

data/test/configs/daemon_events/simple_server.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'daemons'
+
+Daemons.run_proc('daemon-events', {:dir_mode => :system}) do
+  loop { puts 'server'; sleep 1 }
+end

data/test/configs/real.rb

@@ -4,58 +4,56 @@ end
 
 RAILS_ROOT = "/Users/tom/dev/git/helloworld"
 
-God.meddle do |god|
-  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.grace = 5
-    
-    pid_file = File.join(RAILS_ROOT, "log/mongrel.pid")
-    
-    # clean pid files before start if necessary
-    w.behavior(:clean_pid_file) do |b|
-      b.pid_file = pid_file
+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.grace = 5
+  
+  pid_file = File.join(RAILS_ROOT, "log/mongrel.pid")
+  
+  # clean pid files before start if necessary
+  w.behavior(:clean_pid_file) do |b|
+    b.pid_file = pid_file
+  end
+
+  # start if process is not running
+  w.start_if do |start|
+    start.condition(:process_running) do |c|
+      c.running = false
+      c.pid_file = pid_file
     end
+  end
   
-    # start if process is not running
-    w.start_if do |start|
-      start.condition(:process_running) do |c|
-        c.running = false
-        c.pid_file = pid_file
-      end
+  # restart if memory or cpu is too high
+  w.restart_if do |restart|
+    restart.condition(:memory_usage) do |c|
+      c.interval = 20
+      c.pid_file = pid_file
+      c.above = (50 * 1024) # 50mb
+      c.times = [3, 5]
     end
     
-    # restart if memory or cpu is too high
-    w.restart_if do |restart|
-      restart.condition(:memory_usage) do |c|
-        c.interval = 20
-        c.pid_file = pid_file
-        c.above = (50 * 1024) # 50mb
-        c.times = [3, 5]
-      end
-      
-      restart.condition(:cpu_usage) do |c|
-        c.interval = 10
-        c.pid_file = pid_file
-        c.above = 10 # percent
-        c.times = [3, 5]
-      end
+    restart.condition(:cpu_usage) do |c|
+      c.interval = 10
+      c.pid_file = pid_file
+      c.above = 10 # percent
+      c.times = [3, 5]
     end
   end
-  
-  # clear old session files
-  # god.watch do |w|
-  #   w.name = "local-session-cleanup"
-  #   w.start = lambda do
-  #     Dir["#{RAILS_ROOT}/tmp/sessions/ruby_sess.*"].select do |f|
-  #       File.mtime(f) < Time.now - (7 * 24 * 60 * 60)
-  #     end.each { |f| File.delete(f) }
-  #   end
-  #   
-  #   w.start_if do |start|
-  #     start.condition(:always)
-  #   end
-  # end
-end
+end
+
+# clear old session files
+# god.watch do |w|
+#   w.name = "local-session-cleanup"
+#   w.start = lambda do
+#     Dir["#{RAILS_ROOT}/tmp/sessions/ruby_sess.*"].select do |f|
+#       File.mtime(f) < Time.now - (7 * 24 * 60 * 60)
+#     end.each { |f| File.delete(f) }
+#   end
+#   
+#   w.start_if do |start|
+#     start.condition(:always)
+#   end
+# end

data/test/configs/test.rb

@@ -2,74 +2,64 @@ if $0 == __FILE__
   require File.join(File.dirname(__FILE__), *%w[.. .. lib god])
 end
 
-RAILS_ROOT = "/Users/tom/dev/git/helloworld"
+ENV['GOD_TEST_RAILS_ROOT'] || abort("Set a rails root for testing in an environment variable called GOD_TEST_RAILS_ROOT")
 
-God.meddle do |god|
-  god.watch do |w|
-    w.name = "local-3000"
-    w.interval = 5 # seconds
-    w.start = "mongrel_rails start -P ./log/mongrel.pid -c #{RAILS_ROOT} -p 3001 -d"
-    w.stop = "mongrel_rails stop -P ./log/mongrel.pid -c #{RAILS_ROOT}"
-    
-    pid_file = File.join(RAILS_ROOT, "log/mongrel.pid")
-    
-    # clean pid files before start if necessary
-    w.behavior(:clean_pid_file) do |b|
-      b.pid_file = pid_file
-    end
-    
-    # determine the state on startup
-    w.transition(:init, { true => :up, false => :start }) do |on|
-      on.condition(:process_running) do |c|
-        c.running = true
-        c.pid_file = pid_file
-      end
+RAILS_ROOT = ENV['GOD_TEST_RAILS_ROOT']
+
+God.init do |g|
+  # g.host = 
+  # g.port = 7777
+  # g.pid_file_directory = 
+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} -p 3001 -d"
+  w.restart = "mongrel_rails restart -P ./log/mongrel.pid -c #{RAILS_ROOT}"
+  w.stop = "mongrel_rails stop -P ./log/mongrel.pid -c #{RAILS_ROOT}"
+  w.restart_grace = 5.seconds
+  w.stop_grace = 5.seconds
+  w.autostart = true
+  w.uid = 'tom'
+  w.gid = 'tom'
+  w.group = 'mongrels'
+  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
-    
-    # determine when process has finished starting
-    w.transition([:start, :restart], :up) do |on|
-      on.condition(:process_running) do |c|
-        c.running = true
-        c.pid_file = pid_file
-      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
   
-    # start if process is not running
-    w.transition(:up, :start) do |on|
-      on.condition(:process_exits) do |c|
-        c.pid_file = pid_file
-      end
+  # restart if memory or cpu is too high
+  w.transition(:up, :restart) do |on|
+    on.condition(:memory_usage) do |c|
+      c.interval = 1
+      c.above = 50.megabytes
+      c.times = [3, 5]
     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.pid_file = pid_file
-        c.above = (50 * 1024) # 50mb
-        c.times = [3, 5]
-      end
-      
-      on.condition(:cpu_usage) do |c|
-        c.interval = 10
-        c.pid_file = pid_file
-        c.above = 10 # percent
-        c.times = [3, 5]
-      end
+    on.condition(:cpu_usage) do |c|
+      c.interval = 1
+      c.above = 10.percent
+      c.times = [3, 5]
     end
   end
-  
-  # clear old session files
-  # god.watch do |w|
-  #   w.name = "local-session-cleanup"
-  #   w.start = lambda do
-  #     Dir["#{RAILS_ROOT}/tmp/sessions/ruby_sess.*"].select do |f|
-  #       File.mtime(f) < Time.now - (7 * 24 * 60 * 60)
-  #     end.each { |f| File.delete(f) }
-  #   end
-  #   
-  #   w.start_if do |start|
-  #     start.condition(:always)
-  #   end
-  # end
 end