cognizant 0.0.2 → 0.0.3

data/features/cpu_usage.feature

@@ -0,0 +1,45 @@
+Feature: CPU Usage Condition
+
+  Here I want to test proper handling of cpu_usage condition.
+
+  Background:
+    Given a file named "consume_cpu.rb" with:
+      """ruby
+      require 'timeout'
+      $0 = File.basename(__FILE__) # Useful identification when debugging.
+      data = ''
+      Timeout::timeout(60) do
+        loop do
+          data += '*' * 100
+        end
+      end
+      data = nil
+      """
+    Given a file named "monitor.cz" with:
+      """ruby
+      Cognizant.application 'cpu_usage_app' do
+        pids_dir './cognizant/pids/'
+        logs_dir './cognizant/logs/'
+        monitor 'consume_cpu' do
+          autostart false
+          daemonize!
+          start_command 'ruby ./consume_cpu.rb'
+          check :cpu_usage, :every => 2.seconds, :above => 60.percent, :times => [2, 3], :do => :stop
+        end
+      end
+      """
+
+  @daemon
+  @shell
+  Scenario: Check CPU usage of a process that consumes a lot of CPU
+    Given the daemon is running
+    And the shell is running
+
+    When I run "load monitor.cz" successfully in the shell
+    And I run "use cpu_usage_app" successfully in the shell
+    Then the status of "consume_cpu" should be "stopped"
+
+    When I run "start consume_cpu" successfully in the shell
+    Then the status of "consume_cpu" should be "running"
+
+    And the status of "consume_cpu" should be "stopped"

data/features/daemon.feature

@@ -0,0 +1,12 @@
+Feature: Daemon
+
+  The monitoring daemon needs to run in the background and handle process
+  management and provide a command socket for interaction.
+
+  @daemon
+  Scenario: Start and stop the daemon
+    Given the daemon is running
+    Then a process named "cognizantd" should be running
+
+    When the daemon is stopped
+    Then a process named "cognizantd" should not be running

data/features/flapping.feature

@@ -0,0 +1,39 @@
+Feature: Flapping Check
+
+  Here I want to test proper handling of flapping check.
+
+  Background:
+    Given a file named "monitor.cz" with:
+      """ruby
+      Cognizant.application 'sleep_app' do
+        pids_dir './cognizant/pids/'
+        logs_dir './cognizant/logs/'
+        monitor 'sleep_process' do
+          autostart false
+          daemonize!
+          start_command 'sleep 8'
+          check :flapping, times: 3, within: 1.minute, retry_after: 15.seconds, retries: 0
+        end
+      end
+      """
+
+  @daemon
+  @shell
+  Scenario: Handle a process that restarts every 3 seconds
+    Given the daemon is running
+    And the shell is running
+
+    When I run "load monitor.cz" successfully in the shell
+    And I run "use sleep_app" successfully in the shell
+    Then the status of "sleep_process" should be "stopped"
+
+    When I run "start sleep_process" successfully in the shell
+    # Give 3 seconds grace time for process states to be realized by daemon.
+    Then the status of "sleep_process" should be "running" for 5 seconds
+    # TODO: The process goes through another stopped -> running cycle
+    # before being unmonitored. Add step to handle this.
+    Then the status of "sleep_process" should be "unmonitored" for 12 seconds
+    Then the status of "sleep_process" should be "running" for 5 seconds
+
+    When I run "stop sleep_process" successfully in the shell
+    Then the status of "sleep_process" should be "stopped"

data/features/memory_usage.feature

@@ -0,0 +1,45 @@
+Feature: Memory Usage Condition
+
+  Here I want to test proper handling of memory_usage condition.
+
+  Background:
+    Given a file named "consume_memory.rb" with:
+      """ruby
+      require 'timeout'
+      $0 = File.basename(__FILE__) # Useful identification when debugging.
+      data = ''
+      Timeout::timeout(60) do
+        loop do
+          data += '*' * 100
+        end
+      end
+      data = nil
+      """
+    Given a file named "monitor.cz" with:
+      """ruby
+      Cognizant.application 'memory_usage_app' do
+        pids_dir './cognizant/pids/'
+        logs_dir './cognizant/logs/'
+        monitor 'consume_memory' do
+          autostart false
+          daemonize!
+          start_command 'ruby ./consume_memory.rb'
+          check :memory_usage, :every => 2.seconds, :above => 10.megabytes, :times => [2, 3], :do => :stop
+        end
+      end
+      """
+
+  @daemon
+  @shell
+  Scenario: Check memory usage of a process that consumes a lot of memory
+    Given the daemon is running
+    And the shell is running
+
+    When I run "load monitor.cz" successfully in the shell
+    And I run "use memory_usage_app" successfully in the shell
+    Then the status of "consume_memory" should be "stopped"
+
+    When I run "start consume_memory" successfully in the shell
+    Then the status of "consume_memory" should be "running"
+
+    And the status of "consume_memory" should be "stopped"

data/features/shell.feature

@@ -0,0 +1,30 @@
+Feature: Shell
+
+  Cognizant shell provides an interactive interface to pass commands to
+  the monitoring daemon.
+
+  @shell
+  Scenario: Shell should need a deamon to work
+    Then the shell is not running
+
+  @daemon
+  @shell
+  Scenario: Shell should realize that the daemon has gone away
+    Given the daemon is running
+    And the shell is running
+
+    When I run "help" in the shell
+    Then I should see "You can run the following commands" in the shell
+
+    When the daemon is stopped
+    And I run "help" in the shell
+    Then I should see "Error communicating with cognizantd" in the shell
+
+  @daemon
+  @shell
+  Scenario: Shell should prompt about an unrecognized command
+    Given the daemon is running
+    And the shell is running
+
+    When I run "test" in the shell
+    Then I should see "Unrecognized command" in the shell

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,14 @@
+require "aruba/api"
+
+# When /^I run (cognizant) `([^`]*)`$/ do |_, cmd|
+#   cmd = "cognizant #{cmd} --sockfile ./example"
+#   step "I run `#{cmd}`"
+# end
+
+When /^a process named "([^"]*)" (?:should be|is) running$/ do |name|
+  `ps -eo command | grep ^#{name}`.should include(name)
+end
+
+When /^a process named "([^"]*)" (?:should not be|is not) running$/ do |name|
+  `ps -eo command | grep ^#{name}`.should_not include(name)
+end

data/features/step_definitions/daemon_steps.rb

@@ -0,0 +1,25 @@
+When /^the daemon is running$/ do
+  step %Q{I see "Cognizant daemon running successfully." on the daemon terminal}
+end
+
+When /^the daemon is stopped$/ do
+  Process.kill("TERM", @daemon_pipe.pid)
+  sleep 1
+  Process.kill("KILL", @daemon_pipe.pid)
+end
+
+When /^I (?:should )?see "([^"]*)" on the daemon terminal$/ do |string|
+  output = ""
+
+  begin
+    Timeout::timeout(30) do
+      while not output =~ /#{string}/
+        output += @daemon_pipe.readpartial(1)
+      end
+    end
+  rescue Timeout::Error, EOFError
+    nil
+  end
+
+  output.should include(string)
+end

data/features/step_definitions/shell_steps.rb

@@ -0,0 +1,96 @@
+When /^the shell is running$/ do
+  step %Q{I see "You are speaking to the Cognizant Monitoring Daemon." in the shell}
+end
+
+When /^the shell is not running$/ do
+  step %Q{I see "Could not connect to Cognizant daemon process" in the shell}
+end
+
+When /^I run "([^"]*)" in the shell$/ do |string|
+  @shell_pipe.puts(string)
+  sleep 0.5
+end
+
+When /^I run "([^"]*)" successfully in the shell$/ do |cmd|
+  step %Q{I run "#{cmd}" in the shell}
+  step %Q{I should see "OK" in the shell}
+end
+
+# Once we have the required status, it should stay the same in the given next n seconds.
+When /^the (status) of "([^"]*)" (?:should be|is) "([^"]*)" for (\d+) seconds$/ do |_, name, status, timeframe|
+  step %Q{the status of "#{name}" should be "#{status}"}
+
+  output = ""
+
+  begin
+    Timeout::timeout(timeframe.to_i) do
+      catch :stop do
+        loop do
+          buffer = ""
+          @shell_pipe.puts("status #{name}")
+          while not buffer =~ /\s#{name}\s.*since/
+            begin
+              buffer << @shell_pipe.readpartial(1)
+            rescue EOFError
+              retry
+            end
+          end
+          # We need just the line where it tells name and status.
+          output = buffer.split("\n").last
+          if buffer =~ /\s#{status}\s/
+            # Take rest before next check.
+            sleep 0.2
+          else
+            # Otherwise stop checking and report output in error.
+            throw :stop
+          end
+        end
+      end
+    end
+  rescue Timeout::Error
+    # We spent the time gracefully as required.
+    nil
+  end
+
+  # Successful if we reach here.
+  output.should include(status)
+end
+
+When /^the (status) of "([^"]*)" (?:should be|is) "([^"]*)"$/ do |_, name, status|
+  output = ""
+  time_step = 0.25
+  time_spent = 0
+  timeout = 30
+  begin
+    Timeout::timeout(time_step) do
+      time_spent += time_step
+      @shell_pipe.puts("status #{name}")
+      while not output =~ /\s#{status}\s/
+        buffer = @shell_pipe.readpartial(1)
+        output += buffer if buffer
+      end
+    end
+  rescue Timeout::Error, EOFError
+    retry unless time_spent > timeout
+  end
+
+  output.should include(status)
+end
+
+When /^I (?:should )?see "([^"]*)" in the shell$/ do |string|
+  sleep 0.5
+  output = ""
+
+  begin
+    Timeout::timeout(30) do
+      while not output =~ /#{string}/
+        buffer = @shell_pipe.readpartial(1)
+        output += buffer if buffer
+      end
+    end
+  rescue Timeout::Error, EOFError
+    nil
+  end
+
+  output.should include(string)
+end

data/features/support/env.rb

@@ -0,0 +1,54 @@
+require 'coveralls'
+Coveralls.wear!
+
+require "aruba/cucumber"
+require "aruba/api"
+require "open3"
+require "fileutils"
+
+Before "@daemon" do
+  in_current_dir do
+    FileUtils.mkdir("cognizant")
+    File.open("cognizantd.yml", "w") do |f|
+      f.write <<-heredoc
+        daemonize: false
+        sockfile: ./cognizant/cognizantd.sock
+        pidfile: ./cognizant/cognizantd.pid
+        logfile: ./cognizant/cognizantd.log
+      heredoc
+    end
+
+    cmd = "cognizantd cognizantd.yml --trace"
+    Aruba.config.hooks.execute(:before_cmd, self, cmd)
+    announcer.dir(Dir.pwd)
+    announcer.cmd(cmd)
+
+    @daemon_pipe = IO.popen(cmd, "r")
+    sleep 2
+  end
+end
+
+After "@daemon" do
+  ::Process.kill("TERM", @daemon_pipe.pid)
+  sleep 0.5
+  ::Process.kill("KILL", @daemon_pipe.pid)
+end
+
+Before "@shell" do
+  in_current_dir do
+    cmd = "cognizant shell --sockfile ./cognizant/cognizantd.sock"
+
+    Aruba.config.hooks.execute(:before_cmd, self, cmd)
+    announcer.dir(Dir.pwd)
+    announcer.cmd(cmd)
+
+    @shell_pipe = IO.popen(cmd, "w+")
+    sleep 1
+  end
+end
+
+After "@shell" do
+  ::Process.kill("TERM", @shell_pipe.pid)
+  sleep 0.5
+  ::Process.kill("KILL", @shell_pipe.pid)
+end

data/lib/cognizant.rb

@@ -1,10 +1,6 @@
 require "active_support/core_ext/numeric"
 require "active_support/duration"
-
-require "cognizant/server"
+require "cognizant/util/fixnum_percent"
 
 module Cognizant
-  def self.monitor(process_name = nil, attributes = {}, &block)
-    Cognizant::Server.daemon.monitor(process_name, attributes, &block)
-  end
 end

data/lib/cognizant/application.rb

@@ -0,0 +1,122 @@
+require "eventmachine"
+
+require "cognizant/controller"
+require "cognizant/interface"
+require "cognizant/system"
+require "cognizant/application/dsl_proxy"
+
+module Cognizant
+  def self.application(application_name = nil, attributes = {}, &block)
+    Cognizant::Controller.daemon.create_application(application_name, attributes, &block)
+  end
+
+  class Application
+    attr_accessor :name, :pids_dir, :logs_dir
+    attr_accessor :processes
+
+    def initialize(name = nil, options = {}, &block)
+      self.setup({ name: name }.merge(options), &block)
+    end
+
+    def setup(options = {}, &block)
+      self.reset!
+
+      set_attributes(options)
+
+      handle_initialize_block(&block) if block
+
+      raise "Application name is missing. Aborting." unless self.name
+      Log[self].info "Loading application #{self.name}..."
+
+      raise "Application processes are missing. Aborting." unless self.processes.keys.size > 0
+
+      self.setup_directories
+    end
+
+    def handle_initialize_block(&block)
+      if block.arity == 0
+        dsl_proxy = Cognizant::Application::DSLProxy.new(self, &block)
+        attributes = dsl_proxy.attributes
+        set_attributes(attributes)
+      else
+        instance_exec(self, &block)
+      end
+    end
+
+    def set_attributes(attributes)
+      procs = {}
+      procs = attributes.delete(:processes) if attributes.has_key?(:processes)
+
+      mons = {}
+      mons = attributes.delete(:monitor) if attributes.has_key?(:monitor)
+
+      # Attributes.
+      attributes.each do |key, value|
+        if self.respond_to?("#{key}=")
+          value = attributes.delete(key)
+          self.send("#{key}=", value)
+        end
+      end
+
+      # Processes.
+      procs.each do |key, value|
+        process(key, value)
+      end
+
+      # Automatically monitor these.
+      mons.each do |key, value|
+        monitor(key, value)
+      end
+    end
+
+    def monitor(process_name = nil, attributes = {}, &block)
+      proc = create_process(process_name, attributes, &block)
+      proc.monitor
+      proc
+    end
+
+    def process(process_name = nil, attributes = {}, &block)
+      create_process(process_name, attributes, &block)
+    end
+
+    def reset!
+      self.name      = nil
+      self.pids_dir  = nil
+      self.logs_dir  = nil
+      self.processes.values.each(&:reset!) if self.processes.is_a?(Hash)
+      self.processes = {}
+    end
+    alias :shutdown! :reset!
+
+    def pids_dir
+      if @pids_dir and expanded_path = File.expand_path(@pids_dir)
+        expanded_path
+      else
+        "/var/run/cognizant/#{self.name}/pids/"
+      end
+    end
+
+    def logs_dir
+      if @logs_dir and expanded_path = File.expand_path(@logs_dir)
+        expanded_path
+      else
+        "/var/log/cognizant/#{self.name}/logs/"
+      end
+    end
+
+    def create_process(process_name, options = {}, &block)
+      p = Cognizant::Process.new(process_name, options, &block)
+      p.instance_variable_set(:@application, self)
+      self.processes[p.name.to_sym] = p
+      p
+    end
+
+    def tick
+      self.processes.values.each(&:tick)
+    end
+
+    def setup_directories
+      Cognizant::System.mkdir(self.pids_dir, self.logs_dir)
+    end
+  end
+end