eye 0.1.11

data/spec/process/system_spec.rb

@@ -0,0 +1,100 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Eye::Process::System" do
+  before :each do
+    @process = Eye::Process.new(C.p1)
+  end
+  
+  it "load_pid_from_file" do
+    File.open(@process[:pid_file_ex], 'w'){|f| f.write("asdf") }
+    @process.load_pid_from_file.should == nil
+
+    File.open(@process[:pid_file_ex], 'w'){|f| f.write(12345) }
+    @process.load_pid_from_file.should == 12345
+
+    FileUtils.rm(@process[:pid_file_ex]) rescue nil    
+    @process.load_pid_from_file.should == nil
+  end
+
+  it "set_pid_from_file" do
+    File.open(@process[:pid_file_ex], 'w'){|f| f.write(12345) }
+    @process.set_pid_from_file
+    @process.pid.should == 12345
+    @process.pid = nil
+  end
+
+  it "save_pid_to_file" do
+    @process.pid = 123456789
+    @process.save_pid_to_file
+    File.read(@process[:pid_file_ex]).to_i.should == 123456789
+  end
+
+  it "clear_pid_file" do
+    @process.pid = 123456789
+    @process.save_pid_to_file
+    File.read(@process[:pid_file_ex]).to_i.should == 123456789
+
+    @process.clear_pid_file.should == true
+    File.exists?(@process[:pid_file_ex]).should == false
+  end
+
+  it "process_realy_running?" do
+    @process.pid = $$
+    @process.process_realy_running?.should == true
+
+    @process.pid = nil
+    @process.process_realy_running?.should == nil
+
+    @process.pid = -123434
+    @process.process_realy_running?.should == false
+  end
+
+  it "send_signal ok" do
+    mock(Eye::System).send_signal(@process.pid, :TERM){ {:status => :ok} }
+    @process.send_signal(:TERM).should == true
+  end
+
+  it "send_signal not ok" do
+    mock(Eye::System).send_signal(@process.pid, :TERM){ {:status => :error} }
+    @process.send_signal(:TERM).should == false
+  end
+
+  it "pid_file_ctime" do
+    File.open(@process[:pid_file_ex], 'w'){|f| f.write("asdf") }
+    sleep 1
+    (Time.now - @process.pid_file_ctime).should > 1.second
+
+    @process.clear_pid_file
+    (Time.now - @process.pid_file_ctime).should < 0.1.second
+  end
+
+  it "with_timeout" do
+    res = @process.with_timeout(0.5) do
+      sleep 0.3
+      11
+    end
+
+    res.should == 11
+
+    res = @process.with_timeout(0.5) do
+      sleep 0.7
+      11
+    end
+    res.should == :timeout
+  end
+  
+  [C.p1, C.p2].each do |cfg|
+    it "blocking execute should not block process actor mailbox #{cfg[:name]}" do
+      @process = Eye::Process.new(cfg.merge(:start_command => "sleep 5", :start_timeout => 10.seconds))
+      tm1 = Time.now
+      @process.start!    
+      sleep 1
+
+      # here mailbox should anwser without blocks
+      @process.name.should == cfg[:name]
+      (Time.now - tm1).should < 2 # seconds
+    end
+  end
+
+end

data/spec/process/triggers/flapping_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Flapping" do
+  before :each do
+    @c = C.p1.merge(      
+      :triggers => C.flapping(:times => 4, :within => 10)
+    )    
+  end
+
+  it "should create trigger from config" do
+    start_ok_process(@c)
+
+    triggers = @process.triggers
+    triggers.size.should == 1
+
+    triggers.first.class.should == Eye::Trigger::Flapping
+    triggers.first.within.should == 10
+    triggers.first.times.should == 4
+  end
+
+  it "should check speedy flapping by default" do
+    start_ok_process(C.p1)
+
+    triggers = @process.triggers
+    triggers.size.should == 1
+
+    triggers.first.class.should == Eye::Trigger::Flapping
+    triggers.first.within.should == 10
+    triggers.first.times.should == 10
+  end
+
+  it "process flapping" do
+    @process = process(@c.merge(:start_command => @c[:start_command] + " -r"))
+    @process.start!
+
+    stub(@process).notify(:warn, anything)
+    mock(@process).notify(:crit, anything)
+
+    sleep 13
+
+    # check flapping happens here
+
+    @process.state_name.should == :unmonitored
+    @process.watchers.keys.should == []
+  end
+
+  it "process flapping emulate with kill" do
+    @process = process(@c.merge(:triggers => C.flapping(:times => 3, :within => 7)))
+
+    @process.start
+
+    # 4 times because, flapping flag, check on next switch
+    4.times do
+      die_process!(@process.pid)
+      sleep 3
+    end
+
+    @process.state_name.should == :unmonitored
+    @process.watchers.keys.should == []
+  end
+
+  it "flapping not happens" do
+    @process = process(@c)
+    @process.start!
+
+    proxy(@process).schedule(:start, anything)
+    proxy(@process).schedule(:check_crush, anything)
+    dont_allow(@process).schedule(:unmonitor)
+
+
+    sleep 5
+
+    # even if process die in middle
+    die_process!(@process.pid)
+
+    sleep 5
+
+    @process.state_name.should == :up    
+  end
+
+end

data/spec/process/update_config_spec.rb

@@ -0,0 +1,63 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "#update_config" do
+  before :each do
+    @cfg = C.p3.merge(:checks => join(C.check_mem, C.check_cpu), :monitor_children => {})    
+    start_ok_process(@cfg)
+    sleep 6
+  end
+
+  after :each do
+    @process.stop if @process
+  end
+
+  it "update only env" do
+    @process.watchers.keys.should == [:check_alive, :check_childs, :check_memory, :check_cpu]
+    @process.childs.keys.size.should == 3
+    child_pids = @process.childs.keys
+    @process[:environment].should == {"ENV1" => "SUPER"}
+
+    @process.update_config(@cfg.merge(:environment => {"ENV2" => "SUPER"}))
+    sleep 5
+
+    @process.state_name.should == :up
+    @process.watchers.keys.should == [:check_alive, :check_childs, :check_memory, :check_cpu]
+    @process.childs.keys.size.should == 3
+    @process.childs.keys.should == child_pids
+    @process[:environment].should == {"ENV2" => "SUPER"}
+    @process.pid.should == @pid
+  end
+
+  it "update watchers" do
+    @process.watchers.keys.should == [:check_alive, :check_childs, :check_memory, :check_cpu]
+    @process.childs.keys.size.should == 3
+    child_pids = @process.childs.keys
+
+    @process.update_config(@cfg.merge(:checks => C.check_mem))
+    sleep 5
+
+    @process.state_name.should == :up
+    @process.watchers.keys.should == [:check_alive, :check_childs, :check_memory]
+    @process.childs.keys.size.should == 3
+    @process.childs.keys.should == child_pids
+    @process.pid.should == @pid
+  end
+
+  it "when disable monitor_children they should remove" do
+    @process.watchers.keys.should == [:check_alive, :check_childs, :check_memory, :check_cpu]
+    @process.childs.keys.size.should == 3
+    child_pids = @process.childs.keys
+
+    @process.update_config(@cfg.merge(:monitor_children => nil))
+    sleep 5
+
+    @process.state_name.should == :up
+    @process.watchers.keys.should == [:check_alive, :check_memory, :check_cpu]
+    @process.childs.keys.size.should == 0
+    @process.pid.should == @pid
+  end
+
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,120 @@
+# -*- encoding : utf-8 -*-
+require 'rubygems'
+require "bundler/setup"
+require 'celluloid'
+
+if ENV['COV']
+  require 'simplecov'
+  SimpleCov.start 
+end
+
+Bundler.require :default
+
+# preload
+Eye::Control
+Eye::Controller
+Eye::Process
+
+class Eye::Controller
+  public :find_objects, :remove_object_from_tree
+end
+
+require 'rspec/mocks'
+require 'fakeweb'
+
+require File.join(File.dirname(__FILE__), %w{support spec_support})
+require File.join(File.dirname(__FILE__), %w{support scheduler_hack})
+
+$logger_path = File.join(File.dirname(__FILE__), %w{spec.log})
+
+def set_glogger
+  Eye::Logger.log_level = Logger::DEBUG
+  Eye::Logger.link_logger($logger_path)
+end
+
+set_glogger
+
+$logger = Eye::Logger.new("spec")
+Celluloid.logger = $logger
+STDERR.reopen($logger_path)
+
+RSpec.configure do |config|
+  config.mock_with :rr
+
+  config.before(:all) do
+    silence_warnings{ Eye::SystemResources::PsAxActor::UPDATE_INTERVAL = 2 }
+  end
+
+  config.before(:each) do
+    FileUtils.rm(C.p1[:pid_file]) rescue nil
+    FileUtils.rm(C.p2[:pid_file]) rescue nil
+
+    @log = C.base[:stdout]
+    FileUtils.rm(@log) rescue nil
+
+    $logger.info "================== #{ self.class.description} '#{ example.description }'========================"
+  end
+
+  config.after(:each) do
+    # clearing all
+
+    if @pid_file
+      FileUtils.rm(@pid_file) rescue nil
+    end
+
+    force_kill_process(@process)
+    force_kill_pid(@pid)
+
+    FileUtils.rm(C.p1[:pid_file]) rescue nil
+    FileUtils.rm(C.p2[:pid_file]) rescue nil
+
+    GC.start # for kill spawned threads
+
+    terminate_old_actors
+
+    # actors = Celluloid::Actor.all.map(&:class)
+    # $logger.info "Actors: #{actors.inspect}"
+  end
+end
+
+def terminate_old_actors
+  Celluloid::Actor.all.each do |actor|
+    next unless actor.alive?
+    if [Eye::Process, Eye::Group, Eye::ChildProcess].include?(actor.class)
+      actor.terminate 
+    end
+  end
+end
+
+def force_kill_process(process)
+  if process && process.alive?
+    pid = process.pid
+
+    process.terminate
+
+    if pid && Eye::System.pid_alive?(pid)
+      Eye::System.send_signal(pid, 9) 
+    end
+
+    process = nil
+  end
+end
+
+def force_kill_pid(pid)
+  if pid && Eye::System.pid_alive?(pid)
+    Eye::System.send_signal(pid, 9) 
+  end
+end
+
+def fixture(name)
+  File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', name))
+end
+
+def join(*args)
+  result = {}
+  args.each do |a|
+    result.merge!(a)
+  end
+
+  result
+end

data/spec/support/rr_celluloid.rb

@@ -0,0 +1,36 @@
+require 'rr'
+require 'rspec/core/mocking/with_rr'
+
+module RR
+
+  module Celluloid
+    def mock(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      s = subject.respond_to?(:wrapped_object) ? subject.wrapped_object : subject
+      super(s, method_name, &definition_eval_block)
+    end
+
+    def stub(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      s = subject.respond_to?(:wrapped_object) ? subject.wrapped_object : subject
+      super(s, method_name, &definition_eval_block)
+    end
+    
+    def dont_allow(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      s = subject.respond_to?(:wrapped_object) ? subject.wrapped_object : subject
+      super(s, method_name, &definition_eval_block)
+    end
+    
+    def proxy(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      s = subject.respond_to?(:wrapped_object) ? subject.wrapped_object : subject
+      super(s, method_name, &definition_eval_block)
+    end
+    
+    def strong(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      s = subject.respond_to?(:wrapped_object) ? subject.wrapped_object : subject
+      super(s, method_name, &definition_eval_block)
+    end
+
+  end
+  
+end
+
+RSpec::Core::MockFrameworkAdapter.send(:include, RR::Celluloid)

data/spec/support/scheduler_hack.rb

@@ -0,0 +1,16 @@
+module Eye::Process::SchedulerHack
+
+  def scheduled_action(command, *args, &block)
+    super
+
+    schedule_history << command
+  end
+
+  def schedule_history
+    @schedule_history ||= Eye::Process::StatesHistory.new(100)
+  end
+
+end
+
+Eye::Process.send :include, Eye::Process::SchedulerHack
+Eye::Group.send :include, Eye::Process::SchedulerHack

data/spec/support/spec_support.rb

@@ -0,0 +1,164 @@
+# -*- encoding : utf-8 -*-
+module C
+  extend self
+
+  def sample_dir
+    File.expand_path(File.join(File.dirname(__FILE__), %w{.. example}))
+  end
+  
+  def pid_name
+    "1.pid"
+  end
+  
+  def log_name
+    "1111.log"
+  end
+
+  def base
+    {
+      :environment => {"ENV1" => "SUPER"},
+      :working_dir => sample_dir,
+      :application => "main",
+      :group => "default",
+      :name => "base",
+      :pid_file => sample_dir + "/#{pid_name}",
+      :stdout => sample_dir + "/#{log_name}",
+      :stderr => sample_dir + "/#{log_name}",
+      :check_alive_period => 1.seconds,
+      :start_timeout => 5.seconds,
+      :stop_timeout => 2.seconds,      
+    }
+  end
+
+  # eye daemonize process
+  def p1 
+    base.merge(
+      :name => "blocking process",
+      :start_command => "ruby sample.rb",
+      :daemonize => true
+    )
+  end
+
+  # self daemonized process
+  def p2
+    base.merge(
+      :name => "self daemonized process",
+      :start_command => "ruby sample.rb -d --pid #{pid_name} --log #{log_name}",
+    )
+  end
+
+  # forking example
+  def p3
+    base.merge(
+      :name => "forking",
+      :start_command => "ruby forking.rb start",
+      :stop_command => "ruby forking.rb stop",
+      :pid_file => "forking.pid",
+      :childs_update_period => Eye::SystemResources::PsAxActor::UPDATE_INTERVAL + 1,
+      :stop_timeout => 5.seconds,
+      :start_timeout => 15.seconds
+    )
+  end
+
+  # event machine
+  def p4
+    base.merge(
+      :pid_file => "em.pid",
+      :name => "em",
+      :start_command => "ruby em.rb",
+      :daemonize => true,
+      :start_grace => 3.5,
+      :stop_grace => 0.5
+    )
+  end
+
+  def check_mem(a = {})
+    {:memory => {:type => :memory, :every => 2.seconds, :below => 100.megabytes, :times => [3,5]}.merge(a)}
+  end
+
+  def check_cpu(a = {})
+    {:cpu => {:type => :cpu, :every => 2.seconds, :below => 80, :times => [4,5]}.merge(a)}
+  end
+
+  def check_ctime(a = {})
+    {:ctime => {:type => :ctime, :every => 2, :file => sample_dir + "/#{log_name}", :times => [3,5]}.merge(a)}
+  end
+
+  def check_fsize(a = {})
+    {:fsize => {:type => :fsize, :every => 2, :file => sample_dir + "/#{log_name}", :times => [3,5]}.merge(a)}
+  end
+
+  def check_http(a = {})
+    {:http => {
+      :type => :http, :every => 2, :times => 1,
+      :url => "http://localhost:3000/bla", :kind => :sucess, 
+      :pattern => /OK/, :timeout => 3.seconds
+    }.merge(a)
+    }
+  end
+
+  def flapping(a = {})
+    {:flapping => { :type => :flapping, :times => 2, :within => 10.seconds }.merge(a)}
+  end
+
+  def restart_sync
+    {:restart => {:action => :restart, :type => :sync, :grace => 5}}
+  end
+
+  def restart_async
+    {:restart => {:action => :restart, :type => :async, :grace => 5}}
+  end
+  
+  def socket_path
+    File.join(sample_dir, 'sock1')
+  end
+
+end
+
+class TrapError
+  include Celluloid
+
+  trap_exit :actor_died
+
+  def actor_died(actor, reason)
+    if reason
+      $logger.error "Actor Died! #{actor.inspect} has died because of a #{reason.inspect}"
+    end
+    #$logger.error "#{reason.message}"
+    #$logger.error "#{reason.backtrace * "\n"}"
+  end
+end
+
+def process(cfg)  
+  p = Eye::Process.new(cfg)
+  @trap = TrapError.new
+  @trap.link(p)
+  p
+end
+
+def start_ok_process(cfg = C.p1)
+  @process = process(cfg)
+  @process.start
+  sleep 0.2
+
+  @process.process_realy_running?.should == true
+  @process.pid.should > 0
+  @process.watchers.keys.should == [:check_alive] if !cfg[:check_alive] == false
+  @process.state_name.should == :up
+  @pid = @process.pid
+  Eye::System.pid_alive?(@pid).should == true
+
+  @process
+end
+
+def die_process!(pid, signal = :term, int = 0.2)
+  Eye::System.send_signal(pid, signal)
+  sleep int.to_f
+  Eye::System.pid_alive?(pid).should == false
+end
+
+def ensure_kill_samples
+  `ps aux | grep 'ruby sample.rb' | awk '{print $2}' | xargs kill -2 2>/dev/null` rescue nil
+end
+
+require_relative 'rr_celluloid'