eye 0.1.11

data/spec/process/checks/memory_spec.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Process Memory check" do
+
+  before :each do
+    @c = C.p1.merge(
+      :checks => C.check_mem
+    )
+  end
+
+  it "should start periodical watcher" do
+    start_ok_process(@c)
+
+    @process.watchers.keys.should == [:check_alive, :check_memory]
+
+    @process.stop
+
+    # after process stop should remove watcher
+    @process.watchers.keys.should == []
+  end
+
+  describe "1 times" do
+    before :each do
+      @check = {:memory => {:every => 2, :below => 40.megabytes, :times => 1, :type => :memory}}
+    end
+
+    it "when memory exceed limit process should restart" do
+      start_ok_process(@c.merge(:checks => @check))
+      stub(Eye::SystemResources).memory(@process.pid){ 20_000 }
+
+      sleep 3
+
+      stub(Eye::SystemResources).memory(@process.pid){ 50_000 }      
+      mock(@process).notify(:crit, anything)
+      mock(@process).schedule(:restart, anything)
+
+      sleep 1
+    end
+
+    it "else should not restart" do
+      start_ok_process(@c.merge(:checks => @check))
+
+      stub(Eye::SystemResources).memory(@process.pid){ 20_000 }
+      sleep 3
+
+      stub(Eye::SystemResources).memory(@process.pid){ 25_000 }
+      dont_allow(@process).schedule(:restart)
+
+      sleep 1
+    end
+  end
+
+  describe "3 times" do
+    before :each do
+      @check = {:memory => {:every => 2, :below => 40.megabytes, :times => 3, :type => :memory}}
+    end
+
+    it "when memory exceed limit process should restart" do
+      start_ok_process(@c.merge(:checks => @check))
+
+      stub(Eye::SystemResources).memory(@process.pid){ 20_000 }
+      sleep 3
+
+      stub(Eye::SystemResources).memory(@process.pid){ 50_000 }      
+      mock(@process).schedule(:restart, anything)
+
+      sleep 6
+    end
+
+    it "else should not restart" do
+      start_ok_process(@c.merge(:checks => @check))
+
+      stub(Eye::SystemResources).memory(@process.pid){ 20_000 }
+      sleep 3
+
+      stub(Eye::SystemResources).memory(@process.pid){ 25_000 }      
+      dont_allow(@process).schedule(:restart)
+
+      sleep 6
+    end
+  end
+
+  describe "3,5 times" do
+    before :each do
+      @check = {:memory => {:every => 2, :below => 40.megabytes, :times => [3,5], :type => :memory}}
+    end
+
+    it "when memory exceed limit process should restart" do
+      start_ok_process(@c.merge(:checks => @check))
+
+      stub(Eye::SystemResources).memory(@process.pid){ 20_000 }
+      sleep 5
+
+      stub(Eye::SystemResources).memory(@process.pid){ 50_000 }
+      mock(@process).schedule(:restart, anything)
+
+      sleep 6
+    end
+
+    it "else should not restart" do
+      start_ok_process(@c.merge(:checks => @check))
+
+      stub(Eye::SystemResources).memory(@process.pid){ 20_000 }
+      sleep 5
+
+      stub(Eye::SystemResources).memory(@process.pid){ 25_000 }
+      dont_allow(@process).schedule(:restart)
+
+      sleep 6   
+    end
+  end
+
+end

data/spec/process/child_process_spec.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "ChildProcess" do
+
+  describe "starting, monitoring" do
+    after :each do
+      @process.stop if @process
+    end
+
+    it "should monitoring when process has childs and enable option" do
+      cfg = C.p3.merge(:monitor_children => {})
+      start_ok_process(cfg)
+      sleep 5 # ensure that childs finds
+
+      @process.state_name.should == :up
+      @process.childs.keys.should_not == []
+      @process.childs.keys.size.should == 3
+      @process.watchers.keys.should == [:check_alive, :check_childs]
+    end
+
+    it "should not monitoring when process has childs and disable option" do
+      start_ok_process(C.p3)
+      @process.childs.should == {}
+      @process.watchers.keys.should == [:check_alive]
+    end
+
+    it "should not monitoring when process has no childs and enable option" do
+      start_ok_process(C.p1.merge(:monitor_children => {}))
+      @process.childs.should == {}
+      @process.watchers.keys.should == [:check_alive, :check_childs]
+    end
+
+    it "when one of child is die, should update list" do
+      start_ok_process(C.p3.merge(:monitor_children => {}, :childs_update_period => Eye::SystemResources::PsAxActor::UPDATE_INTERVAL + 1)) 
+      @process.watchers.keys.should == [:check_alive, :check_childs]
+
+      sleep 5 # ensure that childs finds
+
+      #p @process.childs
+      pids = @process.childs.keys.sort
+
+      # one of the child is just die
+      died_pid = pids.sample
+      die_process!(died_pid, 9)
+
+      # sleep enought for update list
+      sleep (Eye::SystemResources::PsAxActor::UPDATE_INTERVAL * 2 + 1).seconds
+
+      new_pids = @process.childs.keys.sort
+
+      pids.should_not == new_pids
+      (pids - new_pids).should == [died_pid]
+      (new_pids - pids).size.should == 1
+    end
+
+    it "all childs is die, should update list" do
+      start_ok_process(C.p3.merge(:monitor_children => {}, :childs_update_period => Eye::SystemResources::PsAxActor::UPDATE_INTERVAL + 1)) 
+      @process.watchers.keys.should == [:check_alive, :check_childs]
+
+      sleep 5 # ensure that childs finds
+
+      #p @process.childs
+      master_pid = @process.pid
+      pids = @process.childs.keys.sort
+
+      # one of the child is just die
+      Eye::System.execute("kill -HUP #{master_pid}")
+
+      # sleep enought for update list
+      sleep (Eye::SystemResources::PsAxActor::UPDATE_INTERVAL * 2 + 1).seconds
+
+      new_pids = @process.childs.keys.sort
+
+      master_pid.should == @process.pid
+      new_pids.size.should == 3
+      (pids - new_pids).should == pids
+      (new_pids - pids).should == new_pids
+    end
+
+    it "when process stop, childs cleans" do
+      start_ok_process(C.p3.merge(:monitor_children => {}, :childs_update_period => Eye::SystemResources::PsAxActor::UPDATE_INTERVAL + 1))
+      sleep 5 # ensure that childs finds
+
+      pid = @process.pid
+      @process.watchers.keys.should == [:check_alive, :check_childs]
+      @process.childs.size.should == 3
+
+      @process.stop
+      sleep 2
+      @process.watchers.keys.should == []
+      @process.childs.size.should == 0
+
+      Eye::System.pid_alive?(pid).should == false    
+    end
+
+  end
+
+  describe "add_or_update_childs" do
+    before :each do
+      start_ok_process(C.p1.merge(:monitor_children => {}))
+    end
+
+    it "add new childs, update && remove" do
+      stub(Eye::SystemResources).childs(@process.pid){ [3,4,5] }
+      @process.add_or_update_childs
+      @process.childs.keys.sort.should == [3,4,5]
+
+      stub(Eye::SystemResources).childs(@process.pid){ [3,5,6] }
+      @process.add_or_update_childs
+      @process.childs.keys.sort.should == [3,5,6]
+
+      stub(Eye::SystemResources).childs(@process.pid){ [3,5] }
+      @process.add_or_update_childs
+      @process.childs.keys.sort.should == [3,5]
+
+      stub(Eye::SystemResources).childs(@process.pid){ [6,7] }
+      @process.add_or_update_childs
+      @process.childs.keys.sort.should == [6,7]
+
+      @process.remove_childs
+      @process.childs.should == {}
+    end
+  end
+  
+end

data/spec/process/config_spec.rb

@@ -0,0 +1,75 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Eye::Process::Config" do
+
+  it "should use throught [], c" do
+    @p = Eye::Process.new({:pid_file => '1.pid', :start_command => "a", :working_dir => "/tmp"})
+    @p[:pid_file].should == "1.pid"
+    @p[:pid_file_ex].should == "/tmp/1.pid"
+    @p[:checks].should == {}
+  end
+
+  it "c interface" do
+    @p = Eye::Process.new({:pid_file => '/tmp/1.pid', :start_command => "a"})
+    @p.c(:pid_file_ex).should == "/tmp/1.pid"
+  end
+
+  it "should expand stdout" do
+    @p = Eye::Process.new({:working_dir => "/tmp", :stdout => '1.log', :start_command => "a", :pid_file => '/tmp/1.pid'})
+    @p[:stdout].should == "/tmp/1.log"
+  end
+
+  it "check and triggers should {} if empty" do
+    @p = Eye::Process.new({:working_dir => "/tmp", :stdout => '1.log', :start_command => "a", :pid_file => '/tmp/1.pid', :triggers => {}})
+    @p[:checks].should == {}
+    @p[:triggers].should == {:flapping => {:type=>:flapping, :times=>10, :within=>10}}
+  end
+
+  it "if trigger setted, no rewrite" do
+    @p = Eye::Process.new({:working_dir => "/tmp", :stdout => '1.log', :start_command => "a", :pid_file => '/tmp/1.pid', :triggers => {:flapping => {:type=>:flapping, :times=>100, :within=>100}}})
+    @p[:triggers].should == {:flapping => {:type=>:flapping, :times=>100, :within=>100}}
+  end
+
+  describe "control_pid?" do
+    it "if daemonize than true" do
+      @p = Eye::Process.new({:pid_file => '/tmp/1.pid', :daemonize => true})
+      @p.control_pid?.should == true
+    end
+
+    it "if not daemonize than false" do
+      @p = Eye::Process.new({:pid_file => '/tmp/1.pid'})
+      @p.control_pid?.should == false
+    end
+
+    it "true if not daemonize, but manual" do
+      @p = Eye::Process.new({:pid_file => '/tmp/1.pid', :daemonize => false, :control_pid => true})
+      @p.control_pid?.should == true
+    end
+
+  end
+
+  describe ":childs_update_period" do
+    it "should set default" do
+      @p = Eye::Process.new({:pid_file => '/tmp/1.pid'})
+      @p[:childs_update_period].should == 30.seconds
+    end
+
+    it "should set from global options" do
+      @p = Eye::Process.new({:pid_file => '/tmp/1.pid', :childs_update_period => 11.seconds})
+      @p[:childs_update_period].should == 11.seconds
+    end
+
+    it "should set from monitor_children sub options" do
+      @p = Eye::Process.new({:pid_file => '/tmp/1.pid', :monitor_children => {:childs_update_period => 12.seconds}})
+      @p[:childs_update_period].should == 12.seconds
+    end
+
+    it "should set from monitor_children sub options" do
+      @p = Eye::Process.new({:pid_file => '/tmp/1.pid', :childs_update_period => 11.seconds, :monitor_children => {:childs_update_period => 12.seconds}})
+      @p[:childs_update_period].should == 12.seconds
+    end
+
+  end
+  
+end

data/spec/process/controller_spec.rb

@@ -0,0 +1,173 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Process Controller" do
+
+  describe "monitor" do
+    it "monitor should call start, as the auto_start is default" do
+      @process = process C.p1
+
+      proxy(@process).start
+      @process.monitor
+      sleep 1
+
+      @process.state_name.should == :up
+    end
+
+    it "without auto_start and process not running" do
+      @process = process C.p1.merge(:auto_start => false)
+      @process.monitor
+      sleep 1
+
+      @process.state_name.should == :unmonitored
+    end
+
+    it "without auto_start and process already running" do
+      @pid = Eye::System.daemonize(C.p1[:start_command], C.p1)[:pid]
+      Eye::System.pid_alive?(@pid).should == true
+      File.open(C.p1[:pid_file], 'w'){|f| f.write(@pid) }
+      sleep 2
+
+      @process = process C.p1.merge(:auto_start => false)
+      @process.monitor
+      sleep 1
+
+      @process.state_name.should == :up
+      @process.pid.should == @pid
+    end
+    
+  end
+
+  describe "unmonitor" do    
+    [C.p1, C.p2].each do |cfg|
+      it "should just forget about any process #{cfg[:name]}" do
+        start_ok_process
+        old_pid = @process.pid
+
+        @process.unmonitor
+
+        Eye::System.pid_alive?(old_pid).should == true
+
+        @process.pid.should == nil
+        @process.state_name.should == :unmonitored
+
+        @process.watchers.keys.should == []
+        @process.load_pid_from_file.should == old_pid
+
+        sleep 1
+
+        # event if something now kill the process
+        die_process!(old_pid)
+
+        # nothing try to up it
+        sleep 5
+
+        @process.state_name.should == :unmonitored
+        @process.load_pid_from_file.should == old_pid
+      end
+    end
+  end
+
+  describe "delete" do
+    it "delete monitoring, not kill process" do
+      start_ok_process
+      old_pid = @process.pid
+
+      @process.delete
+      Eye::System.pid_alive?(old_pid).should == true
+      sleep 0.3
+      @process.alive?.should == false
+
+      @process = nil
+    end
+
+    it "if stop_on_delete process die" do
+      start_ok_process(C.p1.merge(:stop_on_delete => true))
+      old_pid = @process.pid
+
+      @process.delete
+      Eye::System.pid_alive?(old_pid).should == false
+      sleep 0.3
+      @process.alive?.should == false
+
+      @process = nil
+    end
+  end
+
+  describe "stop" do
+    it "stop kill process, and moving to unmonitored" do
+      start_ok_process
+
+      @process.stop
+
+      Eye::System.pid_alive?(@pid).should == false    
+      @process.state_name.should == :unmonitored
+      @process.states_history.end?(:down, :unmonitored).should == true
+
+      # should clear pid
+      @process.pid.should == nil
+    end
+
+    it "if cant kill process, moving to unmonitored too" do
+      start_ok_process(C.p1.merge(:stop_command => "which ruby"))
+
+      @process.watchers.keys.should == [:check_alive]
+
+      @process.stop
+
+      Eye::System.pid_alive?(@pid).should == true
+      @process.state_name.should == :unmonitored
+      @process.states_history.end?(:stopping, :unmonitored, :unmonitored).should == true
+
+      # should clear pid
+      @process.pid.should == nil
+      @process.watchers.keys.should == []
+    end
+  end
+
+  describe "process cant start, crush each time" do
+    before :each do
+      @process = process(C.p2.merge(:start_command => C.p2[:start_command] + " -r" ))
+      @process.send_command :start
+    end
+
+    it "we send command to stop it" do
+      # process flapping here some times
+      sleep 10
+
+      # now send stop command
+      @process.send_command :stop
+      sleep 7
+
+      # process should be stopped here
+      @process.state_name.should == :unmonitored
+    end
+
+    it "we send command to unmonitor it" do
+      # process flapping here some times
+      sleep 10
+
+      # now send stop command
+      @process.send_command :unmonitor
+      sleep 7
+
+      # process should be stopped here
+      @process.state_name.should == :unmonitored
+    end
+  end
+
+  describe "signal" do
+    before :each do
+      @process = process(C.p1)
+      @process.pid = 122345
+    end
+
+    it "mock send_signal" do
+      mock(@process).send_signal(9)
+      @process.signal(9)
+
+      mock(@process).send_signal('9')
+      @process.signal('9')
+    end
+  end
+
+end