eye 0.2.4 → 0.3

data/spec/process/update_config_spec.rb

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

@@ -1,128 +0,0 @@
-require 'rubygems'
-require "bundler/setup"
-require 'celluloid'
-
-if ENV['COV']
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "/bundle/"
-  end
-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})
-
-$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)
-
-$logger.info "specs started in process #{$$}"
-
-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
-
-def should_spend(timeout = 0, delta = 0.05, &block)
-  tm1 = Time.now
-  yield
-  (Time.now - tm1).should be_within(delta).of(timeout)
-end

data/spec/support/rr_celluloid.rb

@@ -1,15 +0,0 @@
-require 'rr'
-require 'rspec/core/mocking/with_rr'
-
-module RR::CelluloidExt
-  %w{mock stub dont_allow proxy strong}.each do |_method|
-    module_eval <<-Q
-      def #{_method}(*args)
-        args[0] = args[0].wrapped_object if args[0].respond_to?(:wrapped_object)
-        super
-      end
-    Q
-  end
-end
-
-RSpec::Core::MockFrameworkAdapter.send(:include, RR::CelluloidExt)

data/spec/support/spec_support.rb

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

data/spec/system_resources_spec.rb

@@ -1,56 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Eye::SystemResources" do
-    
-  it "should get memory" do
-    x = Eye::SystemResources.memory($$)
-    x.should > 100
-    x.should < 300_000
-  end
-
-  it "should get cpu" do
-    x = Eye::SystemResources.cpu($$)
-    x.should >= 0
-    x.should <= 150
-  end
-
-  it "should get start time" do
-    x = Eye::SystemResources.start_time($$)
-    x.length.should >= 4
-  end
-
-  it "should get childs" do
-    x = Eye::SystemResources.childs($$)
-    x.is_a?(Array).should == true
-    x.first.should > 0
-    x.size.should > 0
-    x.all?{|c| c > 0 }.should == true
-  end
-
-  it "should cache and update when interval" do
-    Eye::SystemResources.send :reset!
-    stub(Eye::System).ps_aux{ {$$ => {:rss => 123}} }
-
-    silence_warnings{ Eye::SystemResources::PsAxActor::UPDATE_INTERVAL = 1 }
-
-    x1 = Eye::SystemResources.memory($$)
-    x2 = Eye::SystemResources.memory($$)
-    x1.should == x2
-
-    sleep 0.5
-    x3 = Eye::SystemResources.memory($$)
-    x1.should == x3
-
-    stub(Eye::System).ps_aux{ {$$ => {:rss => 124}} }
-
-    sleep 0.7
-    x4 = Eye::SystemResources.memory($$)
-    x1.should == x4 # first value is old
-
-    sleep 0.1
-
-    x5 = Eye::SystemResources.memory($$)
-    x1.should_not == x5 # seconds is new
-  end
-
-end

data/spec/system_spec.rb

@@ -1,174 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Eye::System" do
-
-  it "pid_alive?" do
-    Eye::System.pid_alive?($$).should == true
-    Eye::System.pid_alive?(123456).should == false    
-    Eye::System.pid_alive?(-122).should == false    
-    Eye::System.pid_alive?(nil).should == false
-  end
-
-  it "check_pid_alive" do
-    Eye::System.check_pid_alive($$).should == {:result => true}
-    Eye::System.check_pid_alive(123456)[:error].class.should == Errno::ESRCH
-    Eye::System.check_pid_alive(-122)[:error].should be
-    Eye::System.check_pid_alive(nil).should == {:result => false}
-  end
-
-  it "ps_aux" do
-    h = Eye::System.ps_aux
-    h.size.should > 10
-    x = h[$$]
-    x.should be
-    x.is_a?(Hash).should be_true
-    x[:ppid].should > 1 # parent pid
-    x[:cpu].should >= 0 # proc
-    x[:rss].should > 1000 # memory
-    x[:start_time].length.should >= 4
-  end
-
-  it "prepare env" do
-    Eye::System.send(:prepare_env, {}).should include({})
-    Eye::System.send(:prepare_env, {:environment => {'A' => 'B'}}).should include({'A' => 'B'})    
-    Eye::System.send(:prepare_env, {:environment => {'A' => 'B'}, :working_dir => "/tmp"}).should include({'A' => 'B', 'PWD' => '/tmp'})
-
-    r = Eye::System.send(:prepare_env, {:environment => {'A' => [], 'B' => {}, 'C' => nil, 'D' => 1, 'E' => '2'}})
-    r['A'].should == '[]'
-    r['B'].should == '{}'
-    r['C'].should == nil
-    r['D'].should == '1'
-    r['E'].should == '2'
-  end
-
-  describe "daemonize" do
-    it "daemonize default" do
-      @pid = Eye::System.daemonize("ruby sample.rb", {:environment => {"ENV1" => "SECRET1", 'BLA' => {}}, 
-        :working_dir => C.p1[:working_dir], :stdout => @log})[:pid]
-
-      @pid.should > 0
-
-      # process should be alive
-      Eye::System.pid_alive?(@pid).should == true
-
-      sleep 4
-      
-      # should capture log
-      data = File.read(@log)
-      data.should include("SECRET1")
-      data.should include("- tick")
-    end
-
-    it "daemonize empty" do
-      @pid = Eye::System.daemonize("ruby sample.rb", {:working_dir => C.p1[:working_dir]})[:pid]
-
-      # process should be alive
-      Eye::System.pid_alive?(@pid).should == true
-    end
-
-    it "daemonize empty" do
-      @pid = Eye::System.daemonize("echo 'some'", {:stdout => @log})[:pid]
-
-      sleep 0.3
-
-      data = File.read(@log)
-      data.should == "some\n"
-    end
-
-    it "should add LANG env varible" do
-      mock(Process).spawn({"BLA"=>"1", "LANG"=>ENV_LANG}, 'echo', 'some', anything)
-      stub(Process).detach
-
-      @pid = Eye::System.daemonize("echo 'some'", {:stdout => @log, :environment => {"BLA" => "1"}})[:pid]
-    end
-  end
-
-  describe "execute" do
-    it "sleep and exit" do
-      should_spend(1, 0.2) do
-        Eye::System.execute("sleep 1")
-      end
-    end
-  end
-
-  describe "send signal" do
-    it "send_signal to spec" do
-      Eye::System.send_signal($$, 0)[:result].should == :ok
-    end
-
-    it "send_signal to unexisted process" do
-      res = Eye::System.send_signal(-12234)
-      res[:status].should == nil
-      res[:error].message.should include("No such process")
-    end
-
-    it "send_signal to daemon" do
-      @pid = Eye::System.daemonize("ruby sample.rb", {:working_dir => C.p1[:working_dir]})[:pid]
-
-      # process should be alive
-      Eye::System.pid_alive?(@pid).should == true
-
-      Eye::System.send_signal(@pid, :term)[:result].should == :ok
-      sleep 0.2
-
-      Eye::System.pid_alive?(@pid).should == false
-    end
-
-    it "catch signal in fork" do
-      @pid = Eye::System.daemonize("ruby sample.rb", {:working_dir => C.p1[:working_dir],
-        :stdout => @log})[:pid]
-
-      sleep 4
-
-      Eye::System.send_signal(@pid, :usr1)[:result].should == :ok
-      
-      sleep 0.5
-
-      data = File.read(@log)
-      data.should include("USR1 sig")
-    end
-
-    it "signals transformation" do
-      mock(Process).kill('USR1', 123)
-      Eye::System.send_signal(123, :usr1)
-
-      mock(Process).kill('KILL', 123)
-      Eye::System.send_signal(123, :KILL)
-
-      mock(Process).kill('USR1', 123)
-      Eye::System.send_signal(123, 'usr1')
-
-      mock(Process).kill('KILL', 123)
-      Eye::System.send_signal(123, 'KILL')
-
-      mock(Process).kill(9, 123)
-      Eye::System.send_signal(123, 9)
-
-      mock(Process).kill(9, 123)
-      Eye::System.send_signal(123, '9')
-
-      mock(Process).kill(9, 123)
-      Eye::System.send_signal(123, '-9')
-
-      mock(Process).kill(9, 123)
-      Eye::System.send_signal(123, -9)
-      
-      mock(Process).kill(0, 123)
-      Eye::System.send_signal(123, '0')                  
-    end
-  end
-
-  it "normalized_file" do
-    Eye::System.normalized_file("/tmp/1.rb").should == "/tmp/1.rb"
-    Eye::System.normalized_file("/tmp/1.rb", '/usr').should == "/tmp/1.rb"
-
-    Eye::System.normalized_file("tmp/1.rb").should == Dir.getwd + "/tmp/1.rb"
-    Eye::System.normalized_file("tmp/1.rb", '/usr').should == "/usr/tmp/1.rb"
-
-    Eye::System.normalized_file("./tmp/1.rb").should == Dir.getwd + "/tmp/1.rb"
-    Eye::System.normalized_file("./tmp/1.rb", '/usr/').should == "/usr/tmp/1.rb"
-
-    Eye::System.normalized_file("../tmp/1.rb", '/usr/').should == "/tmp/1.rb"
-  end
-
-end