cognizant 0.0.2 → 0.0.3

data/lib/cognizant/process/pid.rb

@@ -1,24 +1,34 @@
 module Cognizant
   class Process
     module PID
+      def cached_pid
+        if not @process_pid or @process_pid == 0
+          read_pid
+        else
+          @process_pid
+        end
+      end
+
       def read_pid
         if self.pid_command
           str = execute(self.pid_command).stdout.to_i
-          @process_pid = str unless not str or str.zero?
+          process_pid = str unless not str or str.zero?
           # TODO: Write pid to pidfile, since our source was pid_command instead.
         elsif self.pidfile and File.exists?(self.pidfile)
           str = File.read(self.pidfile).to_i
-          @process_pid = str unless not str or str.zero?
+          process_pid = str unless not str or str.zero?
         end
-        @process_pid = 0 unless System.pid_running?(@process_pid)
-        @process_pid
+        process_pid = 0 unless Cognizant::System.pid_running?(process_pid) # If the newly fetched pid is not running, reset it.
+        @process_pid = process_pid
       end
 
+      # Note: Expected that this method is not called to overwrite pidfile if the process daemonizes itself (and hence manages the pidfile by itself).
       def write_pid(pid = nil)
-        @process_pid = pid if pid
-        File.open(self.pidfile, "w") { |f| f.write(@process_pid) } if self.pidfile and @process_pid
+        @process_pid = pid
+        File.open(self.pidfile, "w") { |f| f.write(@process_pid) } if self.pidfile and @process_pid and @process_pid != 0
       end
 
+      # Note: Expected that this method is not called to unlink pidfile if the process daemonizes itself (and hence manages the pidfile by itself).
       def unlink_pid
         File.unlink(self.pidfile) if self.pidfile
       rescue Errno::ENOENT

data/lib/cognizant/process/status.rb

@@ -3,12 +3,24 @@ require "cognizant/system"
 module Cognizant
   class Process
     module Status
+      def process_running?
+        @process_running = begin
+          if @ping_command and run(@ping_command).succeeded?
+            true
+          elsif pid_running?
+            true
+          else
+            false
+          end
+        end
+      end
+
       def pid_running?
-        Cognizant::System.pid_running?(read_pid)
+        Cognizant::System.pid_running?(cached_pid)
       end
 
       def signal(signal, pid = nil)
-        Cognizant::System.signal(signal, (pid || read_pid))
+        Cognizant::System.signal(signal, (pid || cached_pid))
       end
     end
   end

data/lib/cognizant/process/trigger_delegate.rb

@@ -0,0 +1,57 @@
+require "cognizant/process/triggers"
+
+module Cognizant
+  class Process
+    class TriggerDelegate
+      attr_accessor :name, :process, :mutex, :scheduled_events
+
+      def initialize(name, process, options = {}, &block)
+        @name, @process = name, process
+        @mutex = Mutex.new
+        @scheduled_events = []
+
+        @trigger = Cognizant::Process::Triggers[@name].new(options, &block)
+        # TODO: This is hackish even though it keeps trigger implementations simple.
+        @trigger.instance_variable_set(:@delegate, self)
+      end
+
+      def notify(transition)
+        @trigger.notify(transition)
+      end
+
+      def reset!
+        @trigger.reset!
+        self.cancel_all_events
+      end
+
+      def dispatch!(event)
+        @process.dispatch!(event, @name)
+      end
+
+      def schedule_event(event, delay)
+        # TODO: Maybe wrap this in a ScheduledEvent class with methods like cancel.
+        thread = Thread.new(self) do |trigger|
+          begin
+            sleep(delay)
+            trigger.dispatch!(event)
+            trigger.mutex.synchronize do
+              trigger.scheduled_events.delete_if { |_, thread| thread == Thread.current }
+            end
+          rescue StandardError => e
+            puts(e)
+            puts(e.backtrace.join("\n"))
+          end
+        end
+
+        @scheduled_events.push([event, thread])
+      end
+
+      def cancel_all_events
+        Log[self].debug "Canceling all scheduled events"
+        @mutex.synchronize do
+          @scheduled_events.each {|_, thread| thread.kill}
+        end
+      end
+    end
+  end
+end

data/lib/cognizant/process/triggers.rb

@@ -0,0 +1,19 @@
+require "cognizant/process/triggers/trigger"
+
+Dir["#{File.dirname(__FILE__)}/triggers/*.rb"].each do |trigger|
+  require trigger
+end
+
+module Cognizant
+  class Process
+    module Triggers
+      def self.[](name)
+        begin
+          const_get(name.to_s.camelcase)
+        rescue NameError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/cognizant/process/triggers/flapping.rb

@@ -0,0 +1,68 @@
+require "cognizant/util/rotational_array"
+
+module Cognizant
+  class Process
+    module Triggers
+      class Flapping < Trigger
+        TRIGGER_STATES = [:starting, :restarting]
+
+        attr_accessor :times, :within, :retry_after, :retries
+        attr_reader :timeline
+
+        def initialize(options = {})
+          @times       = options[:times]       || 5
+          @within      = options[:within]      || 1
+          @retry_after = options[:retry_after] || 5
+          @retries     = options[:retries]     || 0
+
+          @timeline = Util::RotationalArray.new(@times)
+          @num_of_tries = 0
+        end
+
+        def notify(transition)
+          if TRIGGER_STATES.include?(transition.to_name)
+            self.timeline << Time.now.to_i
+            self.check_flapping
+          end
+        end
+
+        def reset!
+          @timeline.clear
+          @num_of_tries = 0
+        end
+
+        def within_duration?
+          (@timeline.last - @timeline.first) <= self.within
+        end
+
+        def can_retry?
+          # retry_after = 0 means do not retry.
+          self.retry_after > 0 and
+          # retries = 0 means always retry.
+          (self.retries == 0 or (self.retries > 0 and @num_of_tries <= self.retries))
+        end
+
+        def check_flapping
+          # The process has not flapped if we haven't encountered enough incidents.
+          return unless (@timeline.compact.length == self.times)
+
+          # Check if the incident happend within the timeframe.
+          if within_duration?
+            @num_of_tries += 1
+
+            Log[self].debug "Flapping detected (##{@num_of_tries}) for #{@delegate.process.name}(pid:#{@delegate.process.cached_pid})."
+
+            # 0.1 to ensure the state isn't randomly caught in throw :halt below.
+            @delegate.schedule_event(:unmonitor, [0.1, self.retry_after].min)
+            @delegate.schedule_event(:start, self.retry_after) if can_retry?
+
+            @timeline.clear
+
+            # This will prevent a transition from happening in the process state_machine.
+            throw :halt
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cognizant/process/triggers/transition.rb

@@ -0,0 +1,22 @@
+module Cognizant
+  class Process
+    module Triggers
+      class Transition < Trigger
+        def initialize(options = {}, &block)
+          @from = [*options[:from]]
+          @to = [*options[:to]]
+          @do = block
+        end
+
+        def notify(transition)
+          if @from.include?(transition.from_name) and @to.include?(transition.to_name)
+            @do.call(@delegate.process) if @do and @do.respond_to?(:call)
+          end
+        end
+
+        def reset!
+        end
+      end
+    end
+  end
+end

data/lib/cognizant/process/triggers/trigger.rb

@@ -0,0 +1,15 @@
+module Cognizant
+  class Process
+    module Triggers
+      class Trigger
+        def notify(transition)
+          raise "Implement in subclass"
+        end
+
+        def reset!
+          raise "Implement in subclass"
+        end
+      end
+    end
+  end
+end

data/lib/cognizant/shell.rb

@@ -0,0 +1,142 @@
+require "logger"
+require "optparse"
+
+require "readline"
+require "shellwords"
+
+require "cognizant/client"
+
+module Cognizant
+  class Shell
+    def initialize(options = {})
+      @app = ""
+      @app = options[:app] if options.has_key?(:app) and options[:app].to_s.size > 0
+
+      @path_to_socket = "/var/run/cognizant/cognizantd.sock"
+      @path_to_socket = options[:socket] if options.has_key?(:socket) and options[:socket].to_s.size > 0
+
+      @@is_shell = true
+      @@is_shell = options[:shell] if options.has_key?(:shell)
+
+      @autocomplete_keywords = []
+      connect
+    end
+
+    def run(&block)
+      Signal.trap("INT") do
+        Cognizant::Shell.emit("\nGoodbye!")
+        exit(0)
+      end
+
+      emit("Enter 'help' if you're not sure what to do.")
+      emit
+      emit("Type 'quit' or 'exit' to quit at any time.")
+
+      setup_readline(&block)
+    end
+
+    def setup_readline(&block)
+      Readline.completion_proc = Proc.new do |input|
+        case input
+        when /^\//
+          # Handle file and directory name autocompletion.
+          Readline.completion_append_character = "/"
+          Dir[input + '*'].grep(/^#{Regexp.escape(input)}/)
+        else
+          # Handle commands and process name autocompletion.
+          Readline.completion_append_character = " "
+          (@autocomplete_keywords + ['quit', 'exit']).grep(/^#{Regexp.escape(input)}/)
+        end
+      end
+
+      while line = Readline.readline(prompt, true).to_s.strip
+        if line.size > 0
+          command, args = parse_command(line)
+          return emit("Goodbye!") if ['quit', 'exit'].include?(command)
+          run_command(command, args, &block)
+        end
+      end
+    end
+
+    def prompt
+      @app.to_s.size > 0 ? "(#{@app})> " : "> "
+    end
+
+    def run_command(command, args, &block)
+      command = command.to_s
+
+      begin
+        response = @client.command({'command' => command, 'args' => args, 'app' => @app})
+      rescue Errno::EPIPE => e
+        emit("cognizant: Error communicating with cognizantd: #{e} (#{e.class})")
+        exit(1)
+      end
+
+      @app = response["use"] if response.is_a?(Hash) and response.has_key?("use")
+
+      if block
+        block.call(response, command)
+      elsif response.kind_of?(Hash)
+        puts response['message']
+      else
+        puts "Invalid response type #{response.class}: #{response.inspect}"
+      end
+
+      fetch_autocomplete_keywords
+    end
+
+    def parse_command(line)
+      command, *args = Shellwords.shellsplit(line)
+      [command, args]
+    end
+
+    def connect
+      begin
+        @client = Cognizant::Client.for_path(@path_to_socket)
+      rescue Errno::ENOENT => e
+        # TODO: The exit here is a biit of a layering violation.
+        Cognizant::Shell.emit(<<EOF, true)
+Could not connect to Cognizant daemon process:
+
+  #{e}
+
+HINT: Are you sure you are running the Cognizant daemon?  If so, you
+should pass cognizant the socket argument provided to cognizantd.
+EOF
+        exit(1)
+      end
+      ehlo if interactive?
+      fetch_autocomplete_keywords
+    end
+
+    def ehlo
+      response = @client.command('command' => '_ehlo', 'user' => ENV['USER'], 'app' => @app)
+      @app = response["use"] if response.is_a?(Hash) and response.has_key?("use")
+
+      emit(response['message'])
+    end
+
+    def fetch_autocomplete_keywords
+      return unless @@is_shell
+      @autocomplete_keywords = @client.command('command' => '_autocomplete_keywords', 'app' => @app)
+    end
+
+    def self.emit(message = nil, force = false)
+      $stdout.puts(message || '') if interactive? || force
+    end
+
+    def self.interactive?
+      # TODO: It is not a tty during tests.
+      # $stdin.isatty and @@is_shell
+      @@is_shell
+    end
+
+    def emit(*args)
+      self.class.emit(*args)
+    end
+
+    def interactive?
+      self.class.interactive?
+    end
+  end
+end

data/lib/cognizant/system.rb

@@ -1,3 +1,5 @@
+require "fileutils"
+
 require "cognizant/system/signal"
 require "cognizant/system/ps"
 
@@ -24,5 +26,19 @@ module Cognizant
       # Possibly running.
       true
     end
+
+    def unlink_file(path)
+      begin
+        File.unlink(path) if path
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+
+    def mkdir(*directories)
+      [*directories].each do |directory|
+        FileUtils.mkdir_p(File.expand_path(directory))
+      end
+    end
   end
 end

data/lib/cognizant/system/ps.rb

@@ -30,7 +30,7 @@ module Cognizant
           child_pids
         end
 
-        def reset_data
+        def reset_data!
           store.clear unless store.empty?
         end
 

data/lib/cognizant/system/signal.rb

@@ -14,8 +14,8 @@ module Cognizant
           # Return if the process is not running.
           return true unless pid_running?(pid)
 
-          signals = options[:signals] || ["TERM", "INT", "KILL"]
-          timeout = options[:timeout] || 10
+          signals = options[:signals] || ["TERM", "INT"]
+          timeout = options[:timeout] || 30
 
           catch :stopped do
             signals.each do |stop_signal|