eye 0.2.4 → 0.3

data/spec/process/config_spec.rb

@@ -1,74 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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, crash 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

data/spec/process/monitoring_spec.rb

@@ -1,180 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Process Monitoring" do
-
-  [C.p1, C.p2].each do |cfg|
-    it "process crashed, should restart #{cfg[:name]}" do
-      start_ok_process(cfg)
-      old_pid = @pid
-
-      die_process!(@pid)
-      mock(@process).notify(:warn, anything)
-
-      sleep 10 # wait until monitor upping process
-
-      @pid = @process.pid
-      @pid.should_not == old_pid    
-
-      Eye::System.pid_alive?(old_pid).should == false
-      Eye::System.pid_alive?(@pid).should == true
-
-      @process.state_name.should == :up
-      @process.states_history.seq?(:down, :starting, :up).should == true
-      @process.watchers.keys.should == [:check_alive]
-      @process.load_pid_from_file.should == @process.pid
-    end
-
-    it "someone remove pid_file. should rewrite" do
-      start_ok_process(cfg)
-      old_pid = @pid
-      File.exists?(cfg[:pid_file]).should == true
-
-      FileUtils.rm(cfg[:pid_file]) # someone removes it (bad man)
-      File.exists?(cfg[:pid_file]).should == false
-
-      sleep 10 # wait until monitor understand it
-
-      File.exists?(cfg[:pid_file]).should == true
-      @process.pid.should == old_pid
-      @process.load_pid_from_file.should == @process.pid
-      @process.state_name.should == :up
-    end
-
-    it "someone rewrite pid_file. should rewrite for daemonize only" do
-      start_ok_process(cfg)
-      old_pid = @pid
-      @process.load_pid_from_file.should == @pid
-
-      File.open(cfg[:pid_file], 'w'){|f| f.write(99999) }
-      @process.load_pid_from_file.should == 99999
-
-      sleep 10 # wait until monitor understand it
-
-      if cfg[:daemonize]
-        @process.load_pid_from_file.should == @pid
-      else
-        @process.load_pid_from_file.should == 99999
-      end
-
-      @process.pid.should == old_pid
-      @process.state_name.should == :up
-    end
-
-    it "someone rewrite pid_file. and ctime > limit, should rewrite for both" do
-      start_ok_process(cfg)
-      old_pid = @pid
-      @process.load_pid_from_file.should == @pid
-
-      silence_warnings{ Eye::Process::Monitor::REWRITE_FACKUP_PIDFILE_PERIOD = 4.seconds }
-
-      File.open(cfg[:pid_file], 'w'){|f| f.write(99999) }
-      @process.load_pid_from_file.should == 99999
-
-      sleep 15 # wait until monitor understand it
-
-      @process.load_pid_from_file.should == @pid
-
-      @process.pid.should == old_pid
-      @process.state_name.should == :up
-
-      silence_warnings{ Eye::Process::Monitor::REWRITE_FACKUP_PIDFILE_PERIOD = 2.minutes }
-    end
-
-    it "EMULATE UNICORN someone rewrite pid_file and process die (should read actual pid from file)" do
-      start_ok_process(cfg)
-      old_pid = @pid
-
-      # rewrite by another :)
-      @pid = Eye::System.daemonize("ruby sample.rb", {:environment => {"ENV1" => "SECRET1"}, 
-        :working_dir => cfg[:working_dir], :stdout => @log})[:pid]
-
-      File.open(cfg[:pid_file], 'w'){|f| f.write(@pid) }
-
-      die_process!(old_pid)
-
-      sleep 10 # wait until monitor upping process
-
-      @process.pid.should == @pid
-      old_pid.should_not == @pid
-
-      Eye::System.pid_alive?(old_pid).should == false
-      Eye::System.pid_alive?(@pid).should == true
-
-      @process.state_name.should == :up
-      @process.watchers.keys.should == [:check_alive]
-      @process.load_pid_from_file.should == @process.pid
-    end
-
-  end
-
-  it "EMULATE UNICORN2 hard understanding restart case" do
-    start_ok_process(C.p2)
-    old_pid = @pid
-
-    # rewrite by another :)
-    @pid = Eye::System.daemonize("ruby sample.rb", {:environment => {"ENV1" => "SECRET1"}, 
-      :working_dir => C.p2[:working_dir], :stdout => @log})[:pid]
-
-    File.open(C.p2[:pid_file], 'w'){|f| f.write(@pid) }
-
-    sleep 5
-
-    # both processes exists now
-    # and in pid_file writed second pid
-    @process.load_pid_from_file.should == @pid
-    @process.pid.should == old_pid
-
-    die_process!(old_pid)
-
-    sleep 5 # wait until monitor upping process
-
-    @process.pid.should == @pid
-    old_pid.should_not == @pid
-    @process.load_pid_from_file.should == @pid
-
-    Eye::System.pid_alive?(old_pid).should == false
-    Eye::System.pid_alive?(@pid).should == true
-
-    @process.state_name.should == :up
-    @process.watchers.keys.should == [:check_alive]
-    @process.load_pid_from_file.should == @process.pid
-  end
-
-  it "if keep_alive disabled, process should not up" do
-    start_ok_process(C.p1.merge(:keep_alive => false))
-    old_pid = @process.pid
-
-    die_process!(@pid)
-
-    sleep 10 # wait until monitor upping process
-
-    @process.pid.should == nil
-    Eye::System.pid_alive?(@pid).should == false
-
-    @process.state_name.should == :unmonitored
-    @process.watchers.keys.should == []
-    @process.states_history.end?(:up, :down, :unmonitored).should == true
-    @process.load_pid_from_file.should == old_pid # i think this ok
-  end
-
-  it "process in status unmonitored should not up automatically" do
-    start_ok_process(C.p1)
-    old_pid = @pid
-
-    @process.unmonitor
-    @process.state_name.should == :unmonitored
-
-    die_process!(@pid)
-
-    sleep 10 # wait until monitor upping process
-
-    @process.pid.should == nil
-
-    Eye::System.pid_alive?(old_pid).should == false    
-
-    @process.state_name.should == :unmonitored
-    @process.watchers.keys.should == []
-    @process.load_pid_from_file.should == old_pid
-  end
-
-end

data/spec/process/notify_spec.rb

@@ -1,27 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Eye::Process::Notify" do
-  before :each do
-    stub(Eye::System).host{ 'host1' }
-    @process = process(C.p1.merge(:notify => {'vasya' => :warn, 
-      'petya' => :crit, 'somebody' => :crit}))
-  end
-
-  it "should send to notifies warn message" do
-    m = {:message=>"something", :name=>"blocking process", :full_name=>"main:default:blocking process", :pid=>nil, :host=>"host1", :level=>:warn}
-    mock(Eye::Notify).notify('vasya', hash_including(m))
-    @process.notify(:warn, 'something')
-  end
-
-  it "should send to notifies crit message" do
-    m = {:message=>"something", :name=>"blocking process", 
-      :full_name=>"main:default:blocking process", :pid=>nil, 
-      :host=>'host1', :level=>:crit}
-
-    mock(Eye::Notify).notify('vasya', hash_including(m))
-    mock(Eye::Notify).notify('petya', hash_including(m))
-    mock(Eye::Notify).notify('somebody', hash_including(m))
-    @process.notify(:crit, 'something')
-  end
-
-end