eye 0.2.4 → 0.3

data/spec/process/restart_spec.rb

@@ -1,186 +0,0 @@
-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_crash
-      @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_crash
-      @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_crash
-      @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_crash
-      @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_crash
-
-      @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_crash
-
-      @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
-
-  it "restart eye-daemonized lock-process from unmonitored status, and process realy running (WAS a problem)" do
-    start_ok_process(C.p4)
-    @pid = @process.pid
-    @process.unmonitor
-    Eye::System.pid_alive?(@pid).should == true
-
-    @process.restart
-    @process.state_name.should == :up
-
-    Eye::System.pid_alive?(@pid).should == false
-    @process.load_pid_from_file.should_not == @pid
-  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_crash
-      @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

@@ -1,178 +0,0 @@
-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
-
-  it "schedule unexisted method should not raise and break anything" do
-    scheduler = @process.scheduler
-    @process.schedule :hahhaha
-    sleep 0.2
-    @process.alive?.should == true
-    scheduler.alive?.should == true
-  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
-
-    it "save history" do
-      @process.schedule :scheduler_test3, 1, :bla, 3, "reason"
-      sleep 0.1
-      h = @process.schedule_history
-      h.size.should == 1
-      h = h[0]
-      h[:state].should == :scheduler_test3
-      h[:reason].should == "reason"
-    end
-  end
-
-  describe "schedule_in" do
-    it "should schedule to future" do
-      @process.schedule_in(1.second, :scheduler_test3, 1, 2, 3)
-      sleep 0.5
-      @process.test3.should == nil
-      sleep 0.7
-      @process.test3.should == [1,2,3]
-    end
-  end
-end

data/spec/process/start_spec.rb

@@ -1,261 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Process Start" do
-
-  it "process already runned, started new process" do
-    # something already started process
-    @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) }
-
-    # should not try to start something
-    dont_allow(Eye::System).daemonize
-    dont_allow(Eye::System).execute
-
-    # when start process
-    @process = process C.p1
-    @process.start.should == :ok
-
-    # wait while monitoring completely started
-    sleep 0.5
-
-    # pid and should be ok
-    @process.pid.should == @pid  
-    @process.load_pid_from_file.should == @pid
-
-    @process.state_name.should == :up
-    @process.watchers.keys.should == [:check_alive]
-  end
-
-  it "process started and up, receive command start" do
-    @process = process C.p1
-    @process.start.should == {:pid=>@process.pid}
-    sleep 0.5
-    @process.state_name.should == :up
-    @process.watchers.keys.should == [:check_alive]
-
-    @process.start.should == :ok
-    sleep 1
-    @process.state_name.should == :up
-    @process.watchers.keys.should == [:check_alive]
-  end
-
-  [C.p1, C.p2].each do |c|
-    it "start new process, with config #{c[:name]}" do
-      @process = process c
-      @process.start.should == {:pid=>@process.pid}
-
-      sleep 0.5
-
-      @pid = @process.pid
-      @process.load_pid_from_file.should == @pid
-
-      @process.state_name.should == :up
-      @process.watchers.keys.should == [:check_alive]
-    end
-
-    it "pid_file already exists, but process not, with config #{c[:name]}" do
-      File.open(C.p1[:pid_file], 'w'){|f| f.write(1234567) }
-
-      @process = process c
-      @process.start.should == {:pid=>@process.pid}
-
-      sleep 0.5
-
-      @pid = @process.pid
-      @pid.should_not == 1234567
-      @process.load_pid_from_file.should == @pid
-
-      @process.state_name.should == :up
-    end
-
-    it "process crashed, with config #{c[:name]}" do
-      @process = process(c.merge(:start_command => c[:start_command] + " -r" ))
-      @process.start.should == {:error=>:not_realy_running}
-
-      sleep 1
-
-      # may be not saving pid?
-      #@pid = @process.pid
-      #@pid.should > 0
-      #@process.load_pid_from_file.should == @pid
-
-      # should try to up process many times
-      @process.states_history.seq?(:unmonitored, :starting, :down, :starting).should == true
-      @process.states_history.all?(:unmonitored, :starting, :down).should == true
-
-      @process.watchers.keys.should == []
-    end
-
-    it "start with invalid command" do
-      @process = process(c.merge(:start_command => "asdf asdf1 r f324 f324f 32f44f"))
-      mock(@process).check_crash
-      res = @process.start
-      res.should == {:error=>"#<Errno::ENOENT: No such file or directory - asdf>"}
-
-      sleep 0.5
-
-      @process.pid.should == nil
-      @process.load_pid_from_file.should == nil
-      [:starting, :down].should include(@process.state_name)
-      @process.states_history.all?(:unmonitored, :starting, :down).should == true
-    end
-
-    it "start PROBLEM with stdout permissions" do
-      @process = process(c.merge(:stdout => "/var/run/1.log"))
-      mock(@process).check_crash
-      res = @process.start
-      res.should == {:error=>"#<Errno::EACCES: Permission denied - open>"}
-
-      sleep 0.5
-
-      @process.pid.should == nil
-      @process.load_pid_from_file.should == nil
-      [:starting, :down].should include(@process.state_name)
-      @process.states_history.all?(:unmonitored, :starting, :down).should == true
-    end
-
-    it "start PROBLEM binary permissions" do
-      @process = process(c.merge(:start_command => "./sample.rb"))
-      mock(@process).check_crash
-      res = @process.start
-      res.should == {:error=>"#<Errno::EACCES: Permission denied - ./sample.rb>"}
-
-      sleep 0.5
-
-      @process.pid.should == nil
-      @process.load_pid_from_file.should == nil
-      [:starting, :down].should include(@process.state_name)
-      @process.states_history.all?(:unmonitored, :starting, :down).should == true
-    end
-
-  end
-
-  it "C.p1 pid_file failed to write" do
-    @process = process(C.p1.merge(:pid_file => "/tmpasdfasdf/asdfa/dfa/df/ad/fad/fd.pid"))
-    res = @process.start      
-    res.should == {:error=>:cant_write_pid}
-
-    sleep 1
-
-    [:starting, :down].should include(@process.state_name)
-    @process.states_history.seq?(:unmonitored, :starting, :down, :starting).should == true
-    @process.states_history.all?(:unmonitored, :starting, :down).should == true
-
-    @process.watchers.keys.should == []
-  end    
-
-  it "C.p2 pid_file failed to write" do
-    pid = "/tmpasdfasdf/asdfa/dfa/df/ad/fad/fd.pid"
-    @process = process(C.p2.merge(:pid_file => pid,
-      :start_command => "ruby sample.rb -d --pid #{pid} --log #{C.log_name}"))
-    res = @process.start      
-    res.should == {:error=>:pid_not_found}
-
-    sleep 1
-
-    [:starting, :down].should include(@process.state_name)
-    @process.states_history.seq?(:unmonitored, :starting, :down, :starting).should == true
-    @process.states_history.all?(:unmonitored, :starting, :down).should == true
-
-    @process.watchers.keys.should == []
-  end    
-
-  it "long process with #{C.p1[:name]} (with daemonize)" do
-    # this is no matter for starting
-    @process = process(C.p1.merge(:start_command => C.p1[:start_command] + " --daemonize_delay 3", 
-      :start_grace => 2.seconds ))
-    @process.start.should == {:pid=>@process.pid}
-
-    sleep 5
-    Eye::System.pid_alive?(@process.pid).should == true
-    @process.state_name.should == :up
-  end
-
-  it "long process with #{C.p2[:name]}" do
-    @process = process(C.p2.merge(:start_command => C.p2[:start_command] + " --daemonize_delay 3", 
-      :start_timeout => 2.seconds))
-    @process.start.should == {:error=>"#<Timeout::Error: execution expired>"}
-
-    sleep 0.5
-    @process.pid.should == nil
-    @process.load_pid_from_file.should == nil
-
-    [:starting, :down].should include(@process.state_name)
-
-    @process.states_history.seq?(:unmonitored, :starting, :down, :starting).should == true
-    @process.states_history.all?(:unmonitored, :starting, :down).should == true    
-  end
-
-  it "long process with #{C.p2[:name]} but start_timeout is OK" do
-    @process = process(C.p2.merge(:start_command => C.p2[:start_command] + " --daemonize_delay 3", 
-      :start_timeout => 10.seconds))
-    @process.start.should == {:pid => @process.pid}
-
-    @process.load_pid_from_file.should == @process.pid
-    @process.state_name.should == :up
-  end
-
-  # O_o, what checks this spec
-  it "blocking start with lock" do
-    @process = process(C.p2.merge(:start_command => C.p2[:start_command] + " --daemonize_delay 3 -L 1.lock", :start_timeout => 2.seconds))
-    @process.start.should == {:error => "#<Timeout::Error: execution expired>"}
-
-    sleep 0.5
-    @process.pid.should == nil
-    @process.load_pid_from_file.should == nil
-
-    [:starting, :down].should include(@process.state_name)
-
-    @process.states_history.seq?(:unmonitored, :starting, :down, :starting).should == true
-    @process.states_history.all?(:unmonitored, :starting, :down).should == true
-  end
-
-  it "bad config daemonize self daemonized process pid the same" do
-    # little crazy behaviour, but process after first death, upped from pid_file pid
-    # NOT RECOMENDED FOR USE CASE
-    @process = process(C.p2.merge(:daemonize => true, :start_grace => 10.seconds))
-    old_pid = @process.pid
-
-    @process.start.should == {:error => :not_realy_running}
-
-    sleep 5
-
-    # should reload process from pid_file
-    @process.state_name.should == :up
-    @process.pid.should_not == old_pid
-    @process.load_pid_from_file.should == @process.pid    
-  end
-
-  it "bad config daemonize self daemonized process pid different" do
-    # NOT RECOMENDED FOR USE CASE
-    @process = process(C.p2.merge(:daemonize => true, :pid_file => "2.pid", :start_grace => 10.seconds))
-    @process.start.should == {:error => :not_realy_running}
-    @process.pid.should == nil
-    
-    ensure_kill_samples
-  end
-
-  it "without start command" do
-    @process = process(C.p2.merge(:start_command => nil))
-    @process.start.should == :no_start_command
-    sleep 1
-    @process.unmonitored?.should == true
-  end
-
-  [:up, :starting, :stopping, :restarting].each do |st|
-    it "should not start from #{st}" do
-      @process = process(C.p1)
-      @process.state = st.to_s # force set state
-
-      dont_allow(Eye::System).daemonize
-      dont_allow(Eye::System).execute    
-
-      @process.start.should == :state_error
-      @process.state_name.should == st
-
-      @process.pid.should == nil
-    end
-  end
-
-end