samhendley-god 0.7.13

data/lib/god/timeline.rb

@@ -0,0 +1,25 @@
+module God
+  
+  class Timeline < Array
+    # Instantiate a new Timeline
+    #   +max_size+ is the maximum size to which the timeline should grow
+    #
+    # Returns Timeline
+    def initialize(max_size)
+      super()
+      @max_size = max_size
+    end
+    
+    # Push a value onto the Timeline
+    #   +val+ is the value to push
+    #
+    # Returns Timeline
+    def push(val)
+      self.concat([val])
+      shift if size > @max_size
+    end
+    
+    alias_method :<<, :push
+  end
+  
+end

data/lib/god/trigger.rb

@@ -0,0 +1,43 @@
+module God
+  
+  class Trigger
+    
+    class << self
+      attr_accessor :triggers # {task.name => condition}
+    end
+    
+    # init
+    self.triggers = {}
+    @mutex = Mutex.new
+    
+    def self.register(condition)
+      @mutex.synchronize do
+        self.triggers[condition.watch.name] ||= []
+        self.triggers[condition.watch.name] << condition
+      end
+    end
+    
+    def self.deregister(condition)
+      @mutex.synchronize do
+        self.triggers[condition.watch.name].delete(condition)
+        self.triggers.delete(condition.watch.name) if self.triggers[condition.watch.name].empty?
+      end
+    end
+    
+    def self.broadcast(task, message, payload)
+      return unless self.triggers[task.name]
+      
+      @mutex.synchronize do
+        self.triggers[task.name].each do |t|
+          t.process(message, payload)
+        end
+      end
+    end
+    
+    def self.reset
+      self.triggers.clear
+    end
+    
+  end
+  
+end

data/lib/god/watch.rb

@@ -0,0 +1,184 @@
+require 'etc'
+require 'forwardable'
+
+module God
+  
+  class Watch < Task
+    VALID_STATES = [:init, :up, :start, :restart]
+    INITIAL_STATE = :init
+    
+    # config
+    attr_accessor :grace, :start_grace, :stop_grace, :restart_grace
+    
+    extend Forwardable
+    def_delegators :@process, :name, :uid, :gid, :start, :stop, :restart,
+                              :name=, :uid=, :gid=, :start=, :stop=, :restart=,
+                              :pid_file, :pid_file=, :log, :log=, :log_cmd, :log_cmd=, :alive?, :pid,
+                              :unix_socket, :unix_socket=, :chroot, :chroot=, :env, :env=, :signal,
+                              :dir, :dir=
+    # 
+    def initialize
+      super
+      
+      @process = God::Process.new
+      
+      # valid states
+      self.valid_states = VALID_STATES
+      self.initial_state = INITIAL_STATE
+      
+      # no grace period by default
+      self.grace = self.start_grace = self.stop_grace = self.restart_grace = 0
+    end
+    
+    def valid?
+      super && @process.valid?
+    end
+    
+    ###########################################################################
+    #
+    # Behavior
+    #
+    ###########################################################################
+    
+    def behavior(kind)
+      # create the behavior
+      begin
+        b = Behavior.generate(kind, self)
+      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
+    
+    ###########################################################################
+    #
+    # Simple mode
+    #
+    ###########################################################################
+    
+    def start_if
+      self.transition(:up, :start) do |on|
+        yield(on)
+      end
+    end
+    
+    def restart_if
+      self.transition(:up, :restart) do |on|
+        yield(on)
+      end
+    end
+    
+    def stop_if 
+      self.transition(:up, :stop) do |on| 
+        yield(on) 
+      end 
+    end
+    
+    ###########################################################################
+    #
+    # Lifecycle
+    #
+    ###########################################################################
+    
+    # Enable monitoring
+    def monitor
+      # start monitoring at the first available of the init or up states
+      if !self.metrics[:init].empty?
+        self.move(:init)
+      else
+        self.move(:up)
+      end
+    end
+    
+    ###########################################################################
+    #
+    # Actions
+    #
+    ###########################################################################
+    
+    def action(a, c = nil)
+      if Thread.current != self.driver.thread
+        # called from outside Driver
+        
+        # send an async message to Driver
+        self.driver.message(:action, [a, c])
+      else
+        # called from within Driver
+        
+        case a
+        when :start
+          call_action(c, :start)
+          sleep(self.start_grace + self.grace)
+        when :restart
+          if self.restart
+            call_action(c, :restart)
+          else
+            action(:stop, c)
+            action(:start, c)
+          end
+          sleep(self.restart_grace + self.grace)
+        when :stop
+          call_action(c, :stop)
+          sleep(self.stop_grace + self.grace)
+        end
+      end
+      
+      self
+    end
+    
+    def call_action(condition, action)
+      # before
+      before_items = self.behaviors
+      before_items += [condition] if condition
+      before_items.each do |b|
+        info = b.send("before_#{action}")
+        if info
+          msg = "#{self.name} before_#{action}: #{info} (#{b.base_name})"
+          applog(self, :info, msg)
+        end
+      end
+      
+      # log
+      if self.send(action)
+        msg = "#{self.name} #{action}: #{self.send(action).to_s}"
+        applog(self, :info, msg)
+      end
+      
+      @process.call_action(action)
+      
+      # after
+      after_items = self.behaviors
+      after_items += [condition] if condition
+      after_items.each do |b|
+        info = b.send("after_#{action}")
+        if info
+          msg = "#{self.name} after_#{action}: #{info} (#{b.base_name})"
+          applog(self, :info, msg)
+        end
+      end
+    end
+    
+    ###########################################################################
+    #
+    # Registration
+    #
+    ###########################################################################
+    
+    def register!
+      God.registry.add(@process)
+    end
+    
+    def unregister!
+      God.registry.remove(@process)
+    end
+  end
+  
+end

data/test/configs/child_events/child_events.god

@@ -0,0 +1,44 @@
+God.watch do |w|
+  w.name = "child-events"
+  w.interval = 5.seconds
+  w.start = File.join(GOD_ROOT, *%w[test configs child_events simple_server.rb])
+  # w.log = File.join(GOD_ROOT, *%w[test configs child_events god.log])
+  
+  # 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, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+    
+    # failsafe
+    on.condition(:tries) do |c|
+      c.times = 2
+      c.transition = :start
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_exits)
+  end
+  
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 5
+      c.within = 20.seconds
+      c.transition = :unmonitored
+      c.retry_in = 10.seconds
+      c.retry_times = 2
+      c.retry_within = 5.minutes
+    end
+  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,37 @@
+God.watch do |w|
+  w.name = 'child-polls'
+  w.start = File.join(GOD_ROOT, *%w[test configs child_polls simple_server.rb])
+  w.interval = 5
+  w.grace = 2
+  
+  w.start_if do |start|
+    start.condition(:process_running) do |c|
+      c.running = false
+    end
+  end
+  
+  w.restart_if do |restart|
+    restart.condition(:cpu_usage) do |c|
+      c.above = 30.percent
+      c.times = [3, 5]
+    end
+    
+    restart.condition(:memory_usage) do |c|
+      c.above = 10.megabytes
+      c.times = [3, 5]
+    end
+  end
+  
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 3
+      c.within = 60.seconds
+      c.transition = :unmonitored
+      c.retry_in = 10.seconds
+      c.retry_times = 2
+      c.retry_within = 5.minutes
+    end
+  end
+end

data/test/configs/child_polls/simple_server.rb

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby
+
+data = ''
+    
+loop do
+  STDOUT.puts('server');
+  STDOUT.flush;
+  
+  100000.times { data << 'x' }
+  
+  sleep 10
+end

data/test/configs/complex/complex.god

@@ -0,0 +1,59 @@
+God.watch do |w|
+  w.name = "complex"
+  w.interval = 5.seconds
+  w.start = File.join(GOD_ROOT, *%w[test configs complex simple_server.rb])
+  # w.log = File.join(GOD_ROOT, *%w[test configs child_events god.log])
+  
+  # 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, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+    
+    # failsafe
+    on.condition(:tries) do |c|
+      c.times = 2
+      c.transition = :start
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_exits)
+  end
+  
+  # restart if process is misbehaving
+  w.transition(:up, :restart) do |on|
+    on.condition(:complex) do |cc|
+      cc.and(:cpu_usage) do |c|
+        c.above = 0.percent
+        c.times = 1
+      end
+      
+      cc.and(:memory_usage) do |c|
+        c.above = 0.megabytes
+        c.times = 3
+      end
+    end
+  end
+  
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 5
+      c.within = 20.seconds
+      c.transition = :unmonitored
+      c.retry_in = 10.seconds
+      c.retry_times = 2
+      c.retry_within = 5.minutes
+    end
+  end
+end

data/test/configs/complex/simple_server.rb

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

data/test/configs/contact/contact.god

@@ -0,0 +1,84 @@
+God::Contacts::Email.message_settings = {:from => 'support@gravatar.com'}
+
+God::Contacts::Email.server_settings = {
+  :address => "smtp.aa.powerset.com",
+  :port => 25,
+  :domain => "powerset.com"
+}
+
+God::Contacts::Twitter.settings = {
+  # this is for my 'mojombo2' twitter test account
+  # feel free to use it for testing your conditions
+  :username => 'mojombo@gmail.com',
+  :password  => 'gok9we3ot1av2e'
+}
+
+God.contact(:email) do |c|
+  c.name = 'tom'
+  c.email = 'tom@mojombo.com'
+  c.group = 'developers'
+end
+
+God.contact(:email) do |c|
+  c.name = 'vanpelt'
+  c.email = 'vanpelt@example.com'
+  c.group = 'developers'
+end
+
+God.contact(:email) do |c|
+  c.name = 'kevin'
+  c.email = 'kevin@example.com'
+  c.group = 'platform'
+end
+
+God.contact(:twitter) do |c|
+  c.name      = 'tom2'
+  c.group     = 'developers'
+end
+
+God.watch do |w|
+  w.name = "contact"
+  w.interval = 5.seconds
+  w.start = "ruby " + File.join(File.dirname(__FILE__), *%w[simple_server.rb])
+  w.log = "/Users/tom/contact.log"
+  
+  # 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, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+    
+    # failsafe
+    on.condition(:tries) do |c|
+      c.times = 2
+      c.transition = :start
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_exits) do |c|
+      c.notify = {:contacts => ['tom2', 'foobar'], :priority => 1, :category => 'product'}
+    end
+  end
+  
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 5
+      c.within = 20.seconds
+      c.transition = :unmonitored
+      c.retry_in = 10.seconds
+      c.retry_times = 2
+      c.retry_within = 5.minutes
+    end
+  end
+end