cognizant 0.0.2 → 0.0.3

data/lib/cognizant/interface.rb

@@ -0,0 +1,17 @@
+require "eventmachine"
+
+require "cognizant/commands"
+
+module Cognizant
+  class Interface < EventMachine::Connection
+    def post_init
+    end
+
+    def receive_data(args)
+      Cognizant::Commands.process_command(self, args)
+    end
+
+    def unbind
+    end
+  end
+end

data/lib/cognizant/log.rb

@@ -0,0 +1,25 @@
+require "logging"
+
+module Cognizant
+  module Log
+    def self.logger
+      Logging.logger
+    end
+
+    def self.[](name)
+      self.logger[name]
+    end
+
+    def self.stdout
+      Logging.appenders.stdout
+    end
+
+    def self.syslog(*args)
+      Logging.appenders.syslog(*args)
+    end
+
+    def self.file(*args)
+      Logging.appenders.file(*args)
+    end
+  end
+end

data/lib/cognizant/process.rb

@@ -3,13 +3,18 @@ require "thread"
 
 require "state_machine"
 
+require "cognizant/process/dsl_proxy"
 require "cognizant/process/pid"
 require "cognizant/process/status"
 require "cognizant/process/execution"
 require "cognizant/process/attributes"
 require "cognizant/process/actions"
-require "cognizant/process/condition_check"
-require "cognizant/util/symbolize_hash_keys"
+require "cognizant/process/conditions"
+require "cognizant/process/condition_delegate"
+require "cognizant/process/triggers"
+require "cognizant/process/trigger_delegate"
+require "cognizant/process/children"
+require "cognizant/util/transform_hash_keys"
 
 module Cognizant
   class Process
@@ -18,6 +23,7 @@ module Cognizant
     include Cognizant::Process::Execution
     include Cognizant::Process::Attributes
     include Cognizant::Process::Actions
+    include Cognizant::Process::Children
 
     state_machine :initial => :unmonitored do
       # These are the idle states, i.e. only an event (either external or internal) will trigger a transition.
@@ -65,40 +71,69 @@ module Cognizant
         transition any => :unmonitored
       end
 
-      after_transition  any      => :starting,   :do => :start_process
-      before_transition :running => :stopping,   :do => lambda { |p| p.autostart = false }
-      after_transition  any      => :stopping,   :do => :stop_process
-      before_transition any      => :restarting, :do => lambda { |p| p.autostart = true }
-      after_transition  any      => :restarting, :do => :restart_process
+      before_transition any      => :starting,    :do => lambda { |p| p.autostart = true }
+      after_transition  any      => :starting,    :do => :start_process
+
+      before_transition any      => :stopping,    :do => lambda { |p| p.autostart = false }
+      after_transition  :running => :stopping,    :do => :stop_process
+
+      before_transition any      => :restarting,  :do => lambda { |p| p.autostart = true }
+      after_transition  any      => :restarting,  :do => :restart_process
+
+      before_transition any      => :unmonitored, :do => lambda { |p| p.autostart = false }
 
       before_transition any => any, :do => :notify_triggers
       after_transition  any => any, :do => :record_transition
     end
 
-    def initialize(process_name = nil, options = {})
+    def initialize(process_name = nil, attributes = {}, &block)
+      reset!
+
+      @name = process_name.to_s if process_name
+
+      set_attributes(attributes)
+
+      handle_initialize_block(&block) if block
+
+      raise "Process name is missing. Aborting." unless self.name
+      Log[self].info "Loading process #{self.name}..."
+
+      # Let state_machine initialize as well.
+      initialize_state_machines
+    end
+
+    def handle_initialize_block(&block)
+      if block.arity == 0
+        attributes = Cognizant::Process::DSLProxy.new(self, &block).attributes
+        set_attributes(attributes)
+      else
+        instance_exec(self, &block)
+      end
+    end
+
+    def reset!
+      reset_attributes!
+
+      @application = nil
       @ticks_to_skip = 0
-      @checks = []
+      @conditions = []
       @triggers = []
+      @children = []
       @action_mutex = Monitor.new
-      
-      self.name = process_name.to_s if process_name
-      self.autostart = true # Default.
-
-      if options.has_key?(:checks) and options[:checks].kind_of?(Hash)
-        options[:checks].each do |condition_name, args|
-          self.check(condition_name, args)
-        end
-      end
-      options.delete(:checks)
+      @monitor_children = false
+    end
 
-      options.each do |attribute_name, value|
-        self.send("#{attribute_name}=", value) if self.respond_to?("#{attribute_name}=")
+    def check(check_name, options, &block)
+      if klass = Cognizant::Process::Conditions[check_name]
+        @conditions << ConditionDelegate.new(check_name, options.deep_symbolize_keys!, &block)
+      elsif klass = Cognizant::Process::Triggers[check_name]
+        @triggers << TriggerDelegate.new(check_name, self, options.deep_symbolize_keys!, &block)
       end
+    end
 
-      yield(self) if block_given?
-
-      # Let state_machine initialize as well.
-      super
+    def monitor_children(child_process_attributes = {}, &child_process_block)
+      @monitor_children = true
+      @child_process_attributes, @child_process_block = child_process_attributes, child_process_block
     end
 
     def tick
@@ -108,18 +143,28 @@ module Cognizant
       # Invoke the state_machine event.
       super
 
-      self.run_checks if self.running?
+      if self.running? # State method.
+        run_conditions
+
+        if @monitor_children
+          refresh_children!
+          @children.each(&:tick)
+        end
+      end
     end
 
-    def record_transition(transition)
-      unless transition.loopback?
-        @transitioned = true
-        @last_transition_time = Time.now.to_i
+    def skip_ticks_for(skips)
+      # Accept negative skips with the result being >= 0.
+      # +1 so that we don't have to >= and ensure 0 in #skip_tick?.
+      @ticks_to_skip = [@ticks_to_skip + (skips.to_i + 1), 0].max
+    end
 
-        # When a process changes state, we should clear the memory of all the checks.
-        @checks.each { |check| check.clear_history! }
-        puts "#{name} changing from #{transition.from_name} => #{transition.to_name}"
-      end
+    def pidfile
+      @pidfile || File.join(@application.pids_dir, @name + '.pid')
+    end
+
+    def logfile
+      @logfile || File.join(@application.logs_dir, @name + '.log')
     end
 
     def last_transition_time
@@ -127,11 +172,9 @@ module Cognizant
     end
 
     def handle_user_command(command)
-      if command == :unmonitor
-        # When the user issues an unmonitor command, reset any
-        # triggers so that scheduled events gets cleared.
-        @triggers.each { |trigger| trigger.reset! }
-      end
+      # When the user issues a command, reset any
+      # triggers so that scheduled events gets cleared.
+      @triggers.each { |trigger| trigger.reset! }
       dispatch!(command, "user initiated")
     end
 
@@ -145,72 +188,42 @@ module Cognizant
       end
     end
 
-    def check(condition_name, options, &block)
-      klass = Cognizant::Process::Conditions[condition_name]
-      case klass.superclass.name.split("::").last
-      when "TriggerCondition"
-        @triggers << klass.new(self, options.deep_symbolize_keys!)
-      when "PollCondition"
-        @checks << ConditionCheck.new(condition_name, options.deep_symbolize_keys!, &block)
-      end
-    end
-
-    def notify_triggers(transition)
-      @triggers.each { |trigger| trigger.notify(transition) }
-    end
-
-    def run_checks
-      now = Time.now.to_i
+    private
 
-      threads = @checks.collect do |check|
-        [check, Thread.new { Thread.current[:actions] = check.run(read_pid, now) }]
-      end
+    def record_transition(transition)
+      unless transition.loopback?
+        @transitioned = true
+        @last_transition_time = Time.now.to_i
 
-      @transitioned = false
+        # When a process changes state, we should clear the memory of all the conditions.
+        @conditions.each { |condition| condition.clear_history! }
+        Log[self].debug "Changing state of #{name} from #{transition.from_name} => #{transition.to_name}"
 
-      threads.inject([]) do |actions, (check, thread)|
-        thread.join
-        if thread[:actions].size > 0
-          puts "#{check.condition_name} dispatched: #{thread[:actions].join(',')}"
-          thread[:actions].each do |action|
-            actions << [action, check.to_s]
-          end
+        # And we should re-populate its child list.
+        if @monitor_children
+          @children.clear
         end
-        actions
-      end.each do |(action, reason)|
-        break if @transitioned
-        self.dispatch!(action, reason)
+
+        # Update the pid from pidfile, since the state of process changed, if the process is managing it's own pidfile.
+        read_pid if @pidfile
       end
     end
 
-    def process_running?
-      @process_running = begin
-        # Do not assume change when we're giving time to an execution by skipping ticks.
-        if @ticks_to_skip > 0
-          @process_running
-        elsif self.ping_command and run(self.ping_command).succeeded?
-          true
-        elsif pid_running?
-          true
-        else
-          false
+    def set_attributes(attributes)
+      if attributes.has_key?(:checks) and attributes[:checks].kind_of?(Hash)
+        attributes[:checks].each do |check_name, args, &block|
+          check(check_name, args, &block)
         end
       end
-    end
-
-    def pidfile
-      @pidfile = @pidfile || File.join(Cognizant::Server.daemon.pids_dir, self.name + '.pid')
-    end
+      attributes.delete(:checks)
 
-    def logfile
-      @logfile = @logfile || File.join(Cognizant::Server.daemon.logs_dir, self.name + '.log')
-    end
-
-    private
+      if attributes.has_key?(:monitor_children) and attributes[:monitor_children].kind_of?(Hash)
+        monitor_children(attributes[:monitor_children])
+      end
 
-    def skip_ticks_for(skips)
-      # Accept negative skips with the result being >= 0.
-      @ticks_to_skip = [@ticks_to_skip + (skips.to_i + 1), 0].max # +1 so that we don't have to >= and ensure 0 in "skip_tick?".
+      attributes.each do |attribute_name, value|
+        self.send("#{attribute_name}=", value) if self.respond_to?("#{attribute_name}=")
+      end
     end
 
     def skip_tick?
@@ -225,5 +238,36 @@ module Cognizant
       end
       execute(command, options.merge(action_overrides))
     end
+
+    def run_conditions
+      now = Time.now.to_i
+
+      threads = @conditions.collect do |condition|
+        [condition, Thread.new { Thread.current[:actions] = condition.run(cached_pid, now) }]
+      end
+
+      @transitioned = false
+
+      collect_conditions_actions(threads).each do |(action, reason)|
+        break if @transitioned
+        dispatch!(action, reason)
+      end
+    end
+
+    def collect_conditions_actions(threads)
+      threads.inject([]) do |actions, (condition, thread)|
+        thread.join
+        thread[:actions].each do |action|
+          action_name = action.respond_to?(:call) ? "call to custom block" : action
+          Log[self].debug "Dispatching #{action_name} to #{name} for #{condition.to_s.strip}."
+          actions << [action, condition.to_s]
+        end
+        actions
+      end
+    end
+
+    def notify_triggers(transition)
+      @triggers.each { |trigger| trigger.notify(transition) }
+    end
   end
 end

data/lib/cognizant/process/actions.rb

@@ -12,63 +12,52 @@ module Cognizant
 
       private
 
-      def execute_action(result_handler, options)
-        before_command = options[:before]
-        command        = options[:command]
-        after_command  = options[:after]
-        signals        = options[:signals]
-        timeout        = options[:timeout] || 10
-
+      def handle_action(result_handler, options)
         # TODO: Works well but can some refactoring make it more declarative?
         @action_thread = Thread.new do
           result = false
-          queue = Queue.new
-          thread = Thread.new do
-            if before_command and not success = run(before_command).succeeded?
-              queue.push(success)
-              Thread.exit
-            end
+          queue, thread = execute_action(options)
 
-            if (command and success = run(command, options) and success.succeeded?)
-              run(after_command) if after_command
-              queue.push(success)
-              Thread.exit
-            end
-
-            # If the caller has attempted to set signals, then it can handle it's result.
-            if success = send_signals(signals: signals, timeout: timeout)
-              run(after_command) if after_command
-              queue.push(success)
-              Thread.exit
-            end
-
-            queue.push(false)
-            Thread.exit
-          end
-
-          timeout_left = timeout + 1
-          while (timeout_left -= 1) > 0 do
+          time_left = options[:timeout]
+          while time_left >= 0 do
             # If there is something in the queue, we have the required result.
-            if result = queue.pop
-              # Rollback the pending skips, since we finished before timeout.
-              skip_ticks_for(-timeout_left)
+            unless queue.empty?
+              result = queue.pop
               break
             end
             sleep 1
+            time_left -= 1
           end
 
           # Kill the nested thread.
           thread.kill
 
           # Action callback.
-          result_handler.call(result) if result_handler.respond_to?(:call)
-
-          # Kill self.
-          Thread.kill
+          self.send(result_handler, result, time_left) if result_handler.present? and self.respond_to?(result_handler)
         end
+      end
+
+      def execute_action(options)
+        before_command = options[:before]
+        command        = options[:command]
+        after_command  = options[:after]
+        signals        = options[:signals]
+        timeout        = options[:timeout]
 
-        # We skip so that we're not reinformed about the required transition by the tick.
-        skip_ticks_for(timeout)
+        queue = Queue.new
+        thread = Thread.new do
+          # If before_command succeeds, we move to the next command.
+          (before_command and not success = run(before_command).succeeded?) or
+          # If the command is available and it succeeds, we stop here.
+          (command and success = run(command, options) and success.succeeded?) or
+          # As a last try, check for signals. If the action has set signals, then it can handle its result.
+          (success = send_signals(signals: signals, timeout: timeout))
+
+          run(after_command) if success and after_command
+          queue.push(success)
+          Thread.exit
+        end
+        return queue, thread
       end
 
       def send_signals(options = {})

data/lib/cognizant/process/actions/restart.rb

@@ -14,45 +14,101 @@ module Cognizant
         # The command to restart the process with. This command can optionally
         # be similar in behavior to the stop command, since the process will
         # anyways be automatically started again, if autostart is set to true.
+        # Also see restart_expect variable.
         # @return [String] Defaults to nil
         attr_accessor :restart_command
 
         # The signals to pass to the process one by one attempting to restart
         # it. Each signal is passed within the timeout period over equally
-        # distributed intervals (min. 2 seconds). Override with signals without
+        # divided intervals (min. 2 seconds). Override with signals without
         # "KILL" to never force kill the process.
+        # Also see restart_expect variable.
         # e.g. ["TERM", "INT"]
-        # @return [Array] Defaults to ["TERM", "INT", "KILL"]
+        # @return [Array] Defaults to ["QUIT", "TERM", "INT"]
         attr_accessor :restart_signals
 
+        # Whether or not the process is expected to stop itself after the
+        # restart action is executed. If, upon restart action, the process will
+        # stop but not start again by itself, it should be set to true. If the
+        # process will start again within the timeout period, it should be set
+        # to false. For convenience, it defaults to false, if restart_command
+        # or restart_signals are set, as the restart action is then expected to
+        # start itself after a stop.
+        # @return [true, false] Defaults to !restart_command.present? ||
+        # !restart_signals.present?
+        attr_accessor :restart_expect_stopped
+
         # The grace time period in seconds for the process to stop within
         # (for restart). Covers the time period for the restart command or
         # signals. After the timeout is over, the process is checked for
         # running status and if not stopped, it re-enters the auto start
-        # lifecycle based on conditions.
-        # @return [String] Defaults to 10
+        # lifecycle based on conditions. Timeout of request has the same effect
+        # as :stopped setting :restart_expect.
+        # @return [String] Defaults to 30
         attr_accessor :restart_timeout
 
         # The command to run after the process is restarted.
         # @return [String] Defaults to nil
         attr_accessor :restart_after_command
 
+        def restart_expect_stopped!
+          self.restart_expect_stopped = true
+        end
+
+        def restart_expect_stopped
+          unless !!@restart_expect_stopped == @restart_expect_stopped
+            @restart_expect_stopped = !(self.restart_command.present? or self.restart_signals.present?)
+          end
+          @restart_expect_stopped
+        end
+
+        def reset_attributes!
+          self.restart_env = {}
+          self.restart_before_command = nil
+          self.restart_command = nil
+          self.restart_signals = nil
+          self.restart_expect_stopped = nil
+          self.restart_timeout = 30
+          self.restart_after_command = nil
+          super
+        end
+
         def restart_process
-          result_handler = Proc.new do |result|
-            # If it is a boolean and value is true OR if it's an execution result and it succeeded.
-            if (!!result == result and result) or (result.respond_to?(:succeeded?) and result.succeeded?)
-              unlink_pid unless pid_running?
+          # We skip so that we're not reinformed about the required transition by the tick.
+          skip_ticks_for(self.restart_timeout)
+
+          options = {
+            env:      self.env.merge(self.restart_env),
+            before:   self.restart_before_command,
+            command:  self.restart_command,
+            signals:  self.restart_signals || ["QUIT", "TERM", "INT"],
+            after:    self.restart_after_command,
+            timeout:  self.restart_timeout
+          }
+          handle_action('_restart_result_handler', options)
+        end
+
+        # @private
+        def _restart_result_handler(result, time_left = 0)
+          # If it is a boolean and value is true OR if it's an execution result and it succeeded.
+          if (!!result == result and result) or (result.respond_to?(:succeeded?) and result.succeeded?)
+            unlink_pid if not pid_running? and self.daemonize
+
+            # We are not resetting @process_pid here to give process a second of grace period.
+
+            unless self.restart_expect_stopped
+              while (time_left >= 0 and not process_running?) do
+                sleep 1
+                time_left -= 1
+                @process_pid = nil
+              end
             end
+          else
+            @process_pid = nil
           end
-          execute_action(
-            result_handler,
-            env:     (self.env || {}).merge(self.restart_env || {}),
-            before:  self.restart_before_command,
-            command: self.restart_command,
-            signals: self.restart_signals,
-            after:   self.restart_after_command,
-            timeout: self.restart_timeout
-          )
+
+          # Rollback the pending skips.
+          skip_ticks_for(-time_left) if time_left > 0
         end
       end
     end