cognizant 0.0.2 → 0.0.3

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

@@ -33,26 +33,35 @@ module Cognizant
 
         # The grace time period in seconds for the process to start within.
         # Covers the time period for the input and start command. After the
-        # timeout is over, the process the considered not started and it
+        # timeout is over, the process is considered as not started and it
         # re-enters the auto start lifecycle based on conditions.
-        # @return [String] Defaults to 10
+        # @return [String] Defaults to 30
         attr_accessor :start_timeout
 
         # The command to run after the process is started.
         # @return [String] Defaults to nil
         attr_accessor :start_after_command
 
+        def reset_attributes!
+          self.start_env = {}
+          self.start_before_command = nil
+          self.start_command = nil
+          self.start_with_input = nil
+          self.start_with_input_file = nil
+          self.start_with_input_command = nil
+          self.start_timeout = 30
+          self.start_after_command = nil
+          super
+        end
+
         def start_process
-          result_handler = Proc.new do |result|
-            if result.respond_to?(:succeeded?) and result.succeeded?
-              write_pid(result.pid) if result.pid != 0
-            end
-          end
-          execute_action(
-            result_handler,
+          # We skip so that we're not reinformed about the required transition by the tick.
+          skip_ticks_for(self.start_timeout)
+
+          options = {
             name:          self.name,
-            daemonize:     self.daemonize || true,
-            env:           (self.env || {}).merge(self.start_env || {}),
+            daemonize:     self.daemonize,
+            env:           self.env.merge(self.start_env),
             logfile:       self.logfile,
             errfile:       self.errfile,
             before:        self.start_before_command,
@@ -62,7 +71,21 @@ module Cognizant
             input_command: self.start_with_input_command,
             after:         self.start_after_command,
             timeout:       self.start_timeout
-          )
+          }
+          handle_action('_start_result_handler', options)
+        end
+
+        # @private
+        def _start_result_handler(result, time_left = 0)
+          if result.respond_to?(:succeeded?) and result.succeeded?
+            write_pid(result.pid) if self.daemonize and result.pid != 0
+          end
+
+          # Reset cached pid to read from file or command.
+          @process_pid = nil
+
+          # Rollback the pending skips.
+          skip_ticks_for(-time_left) if time_left > 0
         end
       end
     end

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

@@ -18,10 +18,10 @@ module Cognizant
 
         # The signals to pass to the process one by one attempting to stop 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.
         # e.g. ["TERM", "INT"]
-        # @return [Array] Defaults to ["TERM", "INT", "KILL"]
+        # @return [Array] Defaults to ["QUIT", "TERM", "INT"]
         attr_accessor :stop_signals
 
         # The grace time period in seconds for the process to stop within.
@@ -29,29 +29,50 @@ module Cognizant
         # 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
+        # @return [String] Defaults to 30
         attr_accessor :stop_timeout
 
         # The command to run after the process is stopped.
         # @return [String] Defaults to nil
         attr_accessor :stop_after_command
 
+        def reset_attributes!
+          self.stop_env = {}
+          self.stop_before_command = nil
+          self.stop_command = nil
+          self.stop_signals = ["QUIT", "TERM", "INT"]
+          self.stop_timeout = 30
+          self.stop_after_command = nil
+          super
+        end
+
         def stop_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?
-            end
+          # We skip so that we're not reinformed about the required transition by the tick.
+          skip_ticks_for(self.stop_timeout)
+
+          options = {
+            env:      self.env.merge(self.stop_env),
+            before:   self.stop_before_command,
+            command:  self.stop_command,
+            signals:  self.stop_signals,
+            after:    self.stop_after_command,
+            timeout:  self.stop_timeout
+          }
+          handle_action('_stop_result_handler', options)
+        end
+
+        # @private
+        def _stop_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
           end
-          execute_action(
-            result_handler,
-            env:     (self.env || {}).merge(self.stop_env || {}),
-            before:  self.stop_before_command,
-            command: self.stop_command,
-            signals: self.stop_signals,
-            after:   self.stop_after_command,
-            timeout: self.stop_timeout
-          )
+
+          # Reset cached pid to read from file or command.
+          @process_pid = nil
+
+          # Rollback the pending skips.
+          skip_ticks_for(-time_left) if time_left > 0
         end
       end
     end

data/lib/cognizant/process/attributes.rb

@@ -2,10 +2,12 @@ module Cognizant
   class Process
     module Attributes
       # Unique name for the process.
+      # Note: For child processes, this value is set automatically.
       # @return [String]
       attr_accessor :name
 
       # Group classification for the process.
+      # Note: This is not system process group. See `gid` attribute instead.
       # @return [String] Defaults to nil
       attr_accessor :group
 
@@ -16,11 +18,23 @@ module Cognizant
       # @return [true, false] Defaults to true
       attr_accessor :daemonize
 
-      # Whether or not to auto start the process on initial run. Afterwards,
-      # this attribute is overwritten by stop or restart request.
+      # Whether or not to auto start the process when beginning monitoring.
+      # Afterwards, auto start is automatically managed based on user initiated
+      # stop or restart requests.
+      # Note: For child processes, this value is automatically set to false.
       # @return [true, false] Defaults to true
       attr_accessor :autostart
 
+      # The command to check the running status of the process with. The exit
+      # status of the command is used to determine the status.
+      # e.g. "/usr/bin/redis-cli PING"
+      # @return [String] Defaults to nil
+      attr_accessor :ping_command
+
+      # The command that returns the pid of the process.
+      # @return [String] Defaults to nil
+      attr_accessor :pid_command
+
       # The pid lock file for the process. Required when daemonize is set to
       # false.
       # @return [String] Defaults to value of pids_dir/name.pid
@@ -67,15 +81,32 @@ module Cognizant
       # @return [Array] Defaults to []
       attr_accessor :groups
 
-      # The command to check the running status of the process with. The exit
-      # status of the command is used to determine the status.
-      # e.g. "/usr/bin/redis-cli PING"
-      # @return [String] Defaults to nil
-      attr_accessor :ping_command
+      def daemonize!
+        @daemonize = true
+      end
 
-      # The command that returns the pid of the process.
-      # @return [String] Defaults to nil
-      attr_accessor :pid_command
+      def autostart!
+        @autostart = true
+      end
+
+      # @private
+      def reset_attributes!
+        self.name = nil
+        self.group = nil
+        self.daemonize = true
+        self.autostart = false
+        self.ping_command = nil
+        self.pid_command = nil
+        self.pidfile = nil
+        self.logfile = nil
+        self.errfile = nil
+        self.env = {}
+        self.chroot = nil
+        self.chdir = nil
+        self.uid = nil
+        self.gid = nil
+        self.groups = []
+      end
     end
   end
 end

data/lib/cognizant/process/children.rb

@@ -0,0 +1,36 @@
+module Cognizant
+  class Process
+    module Children
+      def refresh_children!
+        # First prune the list of dead children.
+        @children.delete_if do |child|
+          !child.process_running?
+        end
+
+        # Add new found children to the list.
+        new_children_pids = Cognizant::System.get_children(@process_pid) - @children.map(&:cached_pid)
+
+        unless new_children_pids.empty?
+          Log[self].info "Existing children: #{@children.collect{ |c| c.cached_pid }.join(",")}. Got new children: #{new_children_pids.inspect} for #{@process_pid}."
+        end
+
+        # Construct a new process wrapper for each new found children.
+        new_children_pids.each do |child_pid|
+          create_child_process(child_pid)
+        end
+      end
+
+      def create_child_process(child_pid)
+        name = "<child(pid:#{child_pid})>"
+        attributes = @child_process_attributes.merge({ name: name, autostart: false }) # We do not have control over child process' lifecycle, so avoid even attempting to maintain its state with autostart.
+
+        child = Cognizant::Process.new(nil, attributes, &@child_process_block)
+        child.instance_variable_set(:@application, @application)
+        # TODO: Reset pidfile?
+        child.write_pid(child_pid)
+        @children << child
+        child.monitor
+      end
+    end
+  end
+end

data/lib/cognizant/process/{condition_check.rb → condition_delegate.rb}

@@ -3,30 +3,28 @@ require "cognizant/util/rotational_array"
 
 module Cognizant
   class Process
-    class ConditionCheck
+    class ConditionDelegate
       class HistoryValue < Struct.new(:value, :critical); end
 
       # No need to recreate one every tick.
       EMPTY_ARRAY = [].freeze
 
-      attr_accessor :condition_name
-      def initialize(condition_name, options = {}, &block)
-        @condition_name = condition_name
-
-        if block
-          @do = Array(block)
-        else
-          @do = options.has_key?(:do) ? Array(options.delete(:do)) : [:restart]
-        end
+      attr_accessor :name
 
+      def initialize(name, options = {}, &block)
+        @name = name
         @every = options.delete(:every).to_i
-        @times = options.delete(:times) || [1, 1]
+
+        @times = options.delete(:times) || 1
         @times = [@times, @times] unless @times.is_a?(Array) # handles :times => 5
         @times.map(&:to_i)
 
+        @do = options.has_key?(:do) ? [options.delete(:do)] : [:restart]
+        @do = [block] if block
+
         clear_history!
 
-        @condition = Cognizant::Process::Conditions[@condition_name].new(options)
+        @condition = Cognizant::Process::Conditions[@name].new(options)
       end
 
       def run(pid, tick_number = Time.now.to_i)
@@ -52,7 +50,7 @@ module Cognizant
 
       def to_s
         data = @history.collect { |v| v and "#{v.value}#{'*' unless v.critical}" }.join(", ")
-        "#{@condition_name}: [#{data}]\n"
+        "#{@name}: [#{data}]\n"
       end
     end
   end

data/lib/cognizant/process/conditions.rb

@@ -1,15 +1,18 @@
 require "cognizant/process/conditions/poll_condition"
-require "cognizant/process/conditions/trigger_condition"
 
-Dir["#{File.dirname(__FILE__)}/conditions/*.rb"].each do |c|
-  require c
+Dir["#{File.dirname(__FILE__)}/conditions/*.rb"].each do |condition|
+  require condition
 end
 
 module Cognizant
   class Process
     module Conditions
       def self.[](name)
-        const_get(name.to_s.camelcase)
+        begin
+          const_get(name.to_s.camelcase)
+        rescue NameError
+          nil
+        end
       end
     end
   end

data/lib/cognizant/process/conditions/cpu_usage.rb

@@ -4,16 +4,15 @@ module Cognizant
   class Process
     module Conditions
       class CpuUsage < PollCondition
-        def initialize(options = {})
-          @above = options[:above].to_f
-        end
-
         def run(pid)
-          System.cpu_usage(pid).to_f
+          # Check for current value for the given process pid.
+          Cognizant::System.cpu_usage(pid).to_f
         end
 
         def check(value)
-          value > @above
+          # Evaluate the value with threshold.
+          # The result of this decides condition invoking.
+          value > @options[:above].to_f
         end
       end
     end

data/lib/cognizant/process/conditions/memory_usage.rb

@@ -7,16 +7,12 @@ module Cognizant
         MB_LABEL = "MB"
         KB_LABEL = "KB"
 
-        def initialize(options = {})
-          @above = options[:above].to_f
-        end
-
         def run(pid)
-          System.memory_usage(pid).to_f
+          Cognizant::System.memory_usage(pid).to_f
         end
 
         def check(value)
-          value.kilobytes > @above
+          value.kilobytes > @options[:above].to_f
         end
 
         def format_value(value)

data/lib/cognizant/process/dsl_proxy.rb

@@ -0,0 +1,23 @@
+require 'cognizant/util/dsl_proxy_methods_handler'
+
+module Cognizant
+  class Process
+    class DSLProxy
+      include Cognizant::Util::DSLProxyMethodsHandler
+
+      def initialize(process, &dsl_block)
+        super
+        @process = process
+        instance_eval(&dsl_block)
+      end
+
+      def check(condition_name, options, &block)
+        @process.check(condition_name, options, &block)
+      end
+
+      def monitor_children(&child_process_block)
+        @process.monitor_children(&child_process_block)
+      end
+    end
+  end
+end

data/lib/cognizant/process/execution.rb

@@ -1,3 +1,5 @@
+require 'cognizant/util/transform_hash_keys'
+
 module Cognizant
   class Process
     module Execution
@@ -29,15 +31,13 @@ module Cognizant
           if options[:daemonize]
             # Create a new session to detach from the controlling terminal.
             unless ::Process.setsid
-              # raise Koth::RuntimeException.new('cannot detach from controlling terminal')
+              Log[self].error "Cannot detach #{options[:name]} from controlling terminal"
             end
 
             # TODO: Set pgroup: true so that the spawned process is the group leader, and it's death would kill all children as well.
 
             # Prevent inheriting signals from parent process.
-            Signal.trap('TERM', 'SIG_DFL')
-            Signal.trap('INT',  'SIG_DFL')
-            Signal.trap('HUP',  'SIG_DFL')
+            setup_execution_traps
 
             # Give the process a name.
             $0 = options[:name] if options[:name]
@@ -52,7 +52,7 @@ module Cognizant
 
           # TODO: Run popen as spawned process before privileges are dropped for increased abilities?
           stdin_data = options[:input] if options[:input]
-          stdin_data = IO.popen(options[:input_command]).gets if options[:input_command]
+          stdin_data = IO.popen(options[:input_command]).read if options[:input_command]
 
           if stdin_data
             stdin, stdin_w = IO.pipe
@@ -72,8 +72,8 @@ module Cognizant
           })
 
           # Spawn a process to execute the command.
-          process_pid = ::Process.spawn(options[:env], command, spawn_options)
-          # puts "process_pid: #{process_pid} (#{command})"
+          process_pid = ::Process.spawn(options[:env].deep_stringify_keys!, command, spawn_options)
+          # Log[self].debug "process_pid: #{process_pid} (#{command})"
           pid_w.write(process_pid)
 
           if options[:daemonize]
@@ -116,11 +116,11 @@ module Cognizant
 
           # Collect and return stdout, stderr and exitcode.
           return ExecutionResult.new(
-            pid.read.to_i,
+            nil,
             out_r.read,
             err_r.read,
             status.exitstatus,
-            status.exitstatus.zero?
+            status.exitstatus ? status.exitstatus.zero? : false # TODO: What rare case would not have status.existatus?
           )
         end
       end
@@ -164,6 +164,13 @@ module Cognizant
 
       private
 
+      def setup_execution_traps
+        Signal.trap('TERM', 'SIG_DFL')
+        Signal.trap('INT',  'SIG_DFL')
+        Signal.trap('QUIT', 'SIG_DFL')
+        Signal.trap('HUP',  'SIG_DFL')
+      end
+
       def construct_spawn_options(options, overrides = {})
         spawn_options = {}
         [:chdir, :umask].each do |o|