eye 0.1.11

data/spec/process/monitoring_spec.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Process Monitoring" do
+
+  [C.p1, C.p2].each do |cfg|
+    it "process crushed, 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/restart_spec.rb

@@ -0,0 +1,174 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Process Restart" do
+  [C.p1, C.p2].each do |cfg|
+    it "restart by default command #{cfg[:name]}" do
+      start_ok_process(cfg)
+      old_pid = @pid
+
+      dont_allow(@process).check_crush
+      @process.restart
+
+      @process.pid.should_not == old_pid
+      @process.pid.should > 0
+
+      Eye::System.pid_alive?(@pid).should == false
+      Eye::System.pid_alive?(@process.pid).should == true
+
+      @process.state_name.should == :up
+      @process.states_history.seq?(:up, :restarting, :stopping, :down, :starting, :up).should == true
+      @process.watchers.keys.should == [:check_alive]
+
+      @process.load_pid_from_file.should == @process.pid
+    end
+
+    it "stop_command is #{cfg[:name]}" do
+      start_ok_process(cfg.merge(:stop_command => "kill -9 {{PID}}"))
+      old_pid = @pid
+
+      dont_allow(@process).check_crush
+      @process.restart
+
+      @process.pid.should_not == old_pid
+      @process.pid.should > 0
+
+      Eye::System.pid_alive?(@pid).should == false
+      Eye::System.pid_alive?(@process.pid).should == true
+
+      @process.state_name.should == :up
+      @process.watchers.keys.should == [:check_alive]
+
+      @process.load_pid_from_file.should == @process.pid
+    end
+
+    it "emulate restart_command that cant kill (USR1)" do
+      # not trully test, but its ok as should send signal (unicorn case)
+      start_ok_process(cfg.merge(:restart_command => "kill -USR1 {{PID}}"))
+      old_pid = @pid
+
+      dont_allow(@process).check_crush
+      @process.restart
+
+      sleep 3
+      @process.pid.should == old_pid
+
+      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
+      @process.states_history.end?(:up, :restarting, :up).should == true
+
+      File.read(@log).should include("USR1")
+    end
+
+    it "emulate restart as stop,start where stop command does not kill" do
+      # should send command, than wait grace time,
+      # and than even if old process doesnot die, start another one, (looks like bug, but this is not, it just bad using, commands)
+
+      # same situation, when stop command kills so long time, that process cant stop
+      start_ok_process(cfg.merge(:stop_command => "kill -USR1 {{PID}}"))
+      old_pid = @pid
+
+      dont_allow(@process).check_crush
+      @process.restart
+
+      sleep 3
+      @process.pid.should_not == old_pid
+
+      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
+      @process.states_history.end?(:up, :restarting, :stopping, :unmonitored, :starting, :up).should == true
+
+      File.read(@log).should include("USR1")
+    end
+
+    it "bad restart_command is #{cfg[:name]} and its kills" do
+      # not really restartin, just killing
+      # so monitor should see that process died, and up it
+      start_ok_process(cfg.merge(:restart_command => "kill -9 {{PID}}"))
+
+      mock(@process).check_crush
+
+      @process.restart
+      Eye::System.pid_alive?(@pid).should == false      
+      @process.states_history.seq?(:up, :restarting, :down).should == true
+    end
+
+    it "Bad restart command, invalid" do
+      start_ok_process(cfg.merge(:restart_command => "asdfasdf sdf asd fasdf asdf"))
+
+      dont_allow(@process).check_crush
+
+      @process.restart
+      Eye::System.pid_alive?(@pid).should == true
+      @process.states_history.seq?(:up, :restarting, :up).should == true
+    end
+
+    it "restart command timeouted" do
+      start_ok_process(cfg.merge(:restart_command => "sleep 5", :restart_timeout => 3))
+      @process.restart
+
+      sleep 1
+      @process.pid.should == @pid
+
+      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
+      @process.states_history.end?(:up, :restarting, :up).should == true
+    end
+  end
+
+  [:down, :unmonitored, :up].each do |st|
+    it "ok restart from #{st}" do
+      start_ok_process(C.p1)
+      @process.state = st.to_s
+      old_pid = @pid
+
+      dont_allow(@process).check_crush
+      @process.restart
+
+      @process.pid.should_not == old_pid
+      @process.pid.should > 0
+
+      Eye::System.pid_alive?(@pid).should == false
+      Eye::System.pid_alive?(@process.pid).should == true
+
+      @process.state_name.should == :up
+      @process.watchers.keys.should == [:check_alive]
+      @process.states_history.seq?(:restarting, :stopping, :down, :starting, :up).should == true
+
+      @process.load_pid_from_file.should == @process.pid
+    end
+  end
+
+  [:starting, :restarting, :stopping].each do |st|
+    it "not restart from #{st}" do
+      @process = process(C.p1)
+      @process.state = st.to_s # force set state
+
+      dont_allow(@process).stop
+      dont_allow(@process).start      
+
+      @process.restart.should == nil
+      @process.state_name.should == st
+    end
+  end
+
+  it "restart process without start command" do
+    @process = process(C.p2.merge(:start_command => nil))
+    @process.restart
+    sleep 1
+    @process.unmonitored?.should == true
+  end
+
+
+end

data/spec/process/scheduler_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class Eye::Process
+  attr_reader :test1, :test2, :test3, :test1_call
+
+  def scheduler_test1(a)
+    sleep 0.3
+    @test1_call ||= 0
+    @test1_call += 1
+    @test1 = a
+  end
+
+  def scheduler_test2(a, b)
+    sleep 0.6
+    @test2 = [a, b]
+  end
+
+  def scheduler_test3(*args)    
+    @test3 = args
+  end
+
+  public :scheduler
+
+end
+
+describe "Scheduler" do
+  before :each do
+    @process = process C.p1
+  end
+
+  it "should schedule action" do
+    @process.test1.should == nil
+    @process.schedule :scheduler_test1, 1
+    sleep 0.1
+    @process.current_scheduled_command.should == :scheduler_test1
+    @process.test1.should == nil
+    sleep 0.4
+    @process.test1.should == 1
+    @process.current_scheduled_command.should == nil
+  end
+
+  it "should one after another" do
+    @process.test1.should == nil
+    @process.test2.should == nil
+
+    @process.schedule :scheduler_test1, 1
+    @process.schedule :scheduler_test2, 1, 2
+
+    sleep 0.4 
+    @process.test1.should == 1
+    @process.test2.should == nil
+
+    sleep 0.6
+    @process.test1.should == 1
+    @process.test2.should == [1, 2]
+  end
+
+  it "should one after another2" do
+    @process.test1.should == nil
+    @process.test2.should == nil
+
+    @process.schedule :scheduler_test2, 1, 2
+    @process.schedule :scheduler_test1, 1
+    
+    sleep 0.4 
+    @process.test1.should == nil
+    @process.test2.should == nil
+
+    sleep 0.3
+    @process.test1.should == nil
+    @process.test2.should == [1, 2]
+
+    sleep 0.3
+    @process.test1.should == 1
+    @process.test2.should == [1, 2]
+  end
+
+  it "should not scheduler dublicates" do
+    @process.schedule :scheduler_test1, 1
+    @process.schedule :scheduler_test1, 1
+    @process.schedule :scheduler_test1, 1
+
+    sleep 1
+    @process.test1_call.should == 2
+  end
+
+  it "should scheduler dublicates by with different params" do
+    @process.schedule :scheduler_test1, 1
+    @process.schedule :scheduler_test1, 2
+    @process.schedule :scheduler_test1, 3
+
+    sleep 1
+    @process.test1_call.should == 3
+  end
+
+  it "should terminate when actor die" do
+    scheduler = @process.scheduler
+    @process.alive?.should == true
+    scheduler.alive?.should == true
+    @process.terminate
+    @process.alive?.should == false
+    scheduler.alive?.should == false
+  end
+
+  it "should terminate even with tasks" do
+    scheduler = @process.scheduler
+    @process.schedule :scheduler_test1, 1
+    @process.schedule :scheduler_test1, 1
+    @process.schedule :scheduler_test1, 1
+
+    @process.terminate
+    scheduler.alive?.should == false
+  end
+
+  it "when scheduling terminate of the parent actor" do
+    scheduler = @process.scheduler
+    @process.schedule :terminate
+    @process.schedule(:scheduler_test1, 1) rescue nil
+
+    sleep 0.2
+    @process.alive?.should == false
+    scheduler.alive?.should == false
+  end
+
+  describe "reasons" do
+    it "1 param without reason" do
+      @process.schedule :scheduler_test3, 1
+      sleep 0.1
+      @process.last_scheduled_command.should == :scheduler_test3
+      @process.last_scheduled_reason.should == nil
+      @process.test3.should == [1]
+    end
+
+    it "1 param with reason" do
+      @process.schedule :scheduler_test3, 1, "reason"
+      sleep 0.1
+      @process.last_scheduled_command.should == :scheduler_test3
+      @process.last_scheduled_reason.should == 'reason'
+      @process.test3.should == [1]
+    end
+
+    it "many params with reason" do
+      @process.schedule :scheduler_test3, 1, :bla, 3, "reason"
+      sleep 0.1
+      @process.last_scheduled_command.should == :scheduler_test3
+      @process.last_scheduled_reason.should == 'reason'
+      @process.test3.should == [1, :bla, 3]
+    end
+  end
+end