eye 0.2.1 → 0.2.2

data/lib/eye/process/watchers.rb

@@ -9,7 +9,6 @@ module Eye::Process::Watchers
       # default watcher :check_alive
       add_watcher(:check_alive, self[:check_alive_period]) do 
         check_alive
-        GC.start if rand(1000) == 0
       end
 
       # monitor childs pids
@@ -61,8 +60,9 @@ private
     unless subject.check
       return unless up?
       
-      notify :crit, "Bounded #{subject.check_name}: #{subject.last_human_values}"
-      schedule :restart, "bounded #{subject.check_name}"
+      action = subject.fire || :restart
+      notify :crit, "Bounded #{subject.check_name}: #{subject.last_human_values} send to :#{action}"
+      schedule action, "bounded #{subject.check_name}"
     end
   end
 

data/lib/eye/settings.rb

@@ -8,7 +8,7 @@ module Eye::Settings
     if Process::UID.eid == 0 # root
       '/var/run/eye'
     else
-      File.expand_path(File.join(ENV['HOME'], '.eye'))
+      File.expand_path(File.join(ENV['EYE_HOME'] || ENV['HOME'], '.eye'))
     end    
   end
   

data/lib/eye/system.rb

@@ -3,13 +3,28 @@ require 'pathname'
 
 module Eye::System
   class << self
+    # Check that pid realy exits
+    # very fast
+    # return result hash
+    def check_pid_alive(pid)
+      res = if pid 
+        ::Process.kill(0, pid)
+        true
+      else
+        false
+      end
+
+      {:result => res}
+    rescue => ex
+      {:error => ex}
+    end
 
     # Check that pid realy exits
     # very fast
+    # return true/false
     def pid_alive?(pid)
-      pid ? ::Process.kill(0, pid) && true : false
-    rescue Errno::ESRCH, Errno::EPERM
-      false
+      res = check_pid_alive(pid)
+      !!res[:result]
     end
 
     # Send signal to process (uses for kill)
@@ -22,17 +37,15 @@ module Eye::System
       end
       code = code.to_s.upcase if code.is_a?(String) || code.is_a?(Symbol)
 
-      ::Process.kill(code, pid) if pid
-      {:status => :ok}
-
-    rescue Errno::ESRCH    
-      {:status => :error, :message => 'process not found'}
-
-    rescue Errno::EPERM
-      {:status => :error, :message => 'wrong permissions to kill'}
+      if pid
+        ::Process.kill(code, pid) 
+        {:result => :ok}
+      else
+        {:error => Exception.new('no_pid')}
+      end
 
-    rescue => e
-      {:status => :error, :message => "failed signal #{code}: #{e.message}"}
+    rescue => ex
+      {:error => ex}
     end
 
     # Daemonize cmd, and detach
@@ -60,14 +73,18 @@ module Eye::System
       opts = spawn_options(cfg)
       pid  = Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), opts)
 
-      Timeout.timeout(cfg[:timeout] || 1.second) do
+      timeout = cfg[:timeout] || 1.second
+      Timeout.timeout(timeout) do
         Process.waitpid(pid)
       end
 
       {:pid => pid}
 
-    rescue Timeout::Error => ex      
-      send_signal(pid, 9) if pid
+    rescue Timeout::Error => ex
+      if pid
+        Eye.warn "[#{cfg[:name]}] send signal 9 to #{pid} (because of timeouted<#{timeout}> execution)"
+        send_signal(pid, 9)
+      end
       {:error => ex}
 
     rescue Errno::ENOENT, Errno::EACCES => ex

data/lib/eye/trigger.rb

@@ -48,6 +48,6 @@ class Eye::Trigger
     raise 'realize me'
   end
 
-  extend Eye::Checker::Validation
+  extend Eye::Dsl::Validation
 
 end

data/lib/eye/utils/celluloid_chain.rb

@@ -32,6 +32,8 @@ class Eye::Utils::CelluloidChain
     @calls = []
   end
 
+  alias :clear_pending_list :clear
+
   # need, because of https://github.com/celluloid/celluloid/issues/22
   def inspect
     "Celluloid::Chain(#{@target.class}: #{@calls.inspect})"

data/spec/checker/cpu_spec.rb

@@ -51,7 +51,7 @@ describe "Eye::Checker::Cpu" do
     end
 
     it "bad param below" do
-      expect{ Eye::Checker.validate!({:type => :cpu, :every => 5.seconds, :times => 1, :below => {1 => 2}}) }.to raise_error(Eye::Checker::Validation::Error)
+      expect{ Eye::Checker.validate!({:type => :cpu, :every => 5.seconds, :times => 1, :below => {1 => 2}}) }.to raise_error(Eye::Dsl::Validation::Error)
     end
   end
 

data/spec/checker/http_spec.rb

@@ -101,13 +101,13 @@ describe "Eye::Checker::Http" do
     it "without param url" do
       expect{ Eye::Checker.validate!({:type => :http, :every => 5.seconds, 
         :times => 1, :kind => :success,
-        :pattern => /OK/, :timeout => 2}) }.to raise_error(Eye::Checker::Validation::Error)
+        :pattern => /OK/, :timeout => 2}) }.to raise_error(Eye::Dsl::Validation::Error)
     end
 
     it "bad param timeout" do
       expect{ Eye::Checker.validate!({:type => :http, :every => 5.seconds, 
         :times => 1, :kind => :success, :url => "http://localhost:3000/",
-        :pattern => /OK/, :timeout => :fix}) }.to raise_error(Eye::Checker::Validation::Error)
+        :pattern => /OK/, :timeout => :fix}) }.to raise_error(Eye::Dsl::Validation::Error)
     end
   end
 

data/spec/checker/memory_spec.rb

@@ -51,11 +51,11 @@ describe "Eye::Checker::Memory" do
     end
 
     it "bad param below" do
-      expect{ Eye::Checker.validate!({:type => :memory, :every => 5.seconds, :times => 1, :below => {1 => 2}}) }.to raise_error(Eye::Checker::Validation::Error)
+      expect{ Eye::Checker.validate!({:type => :memory, :every => 5.seconds, :times => 1, :below => {1 => 2}}) }.to raise_error(Eye::Dsl::Validation::Error)
     end
 
     it "unknown params" do
-      expect{ Eye::Checker.validate!({:hello => true, :type => :memory, :every => 5.seconds, :times => 1, :below => 10.0.bytes})}.to raise_error(Eye::Checker::Validation::Error)
+      expect{ Eye::Checker.validate!({:hello => true, :type => :memory, :every => 5.seconds, :times => 1, :below => 10.0.bytes})}.to raise_error(Eye::Dsl::Validation::Error)
     end
 
   end

data/spec/checker_spec.rb

@@ -138,7 +138,7 @@ describe "Eye::Checker" do
     end
 
     it "validate by default" do
-      expect{ Checker1.validate({:times => "jopa"}) }.to raise_error(Eye::Checker::Validation::Error)
+      expect{ Checker1.validate({:times => "jopa"}) }.to raise_error(Eye::Dsl::Validation::Error)
     end
   end
 

data/spec/controller/controller_spec.rb

@@ -104,6 +104,12 @@ S
     subject.info_string_short.split("\n").size.should == 2
   end
 
+  it "should delete all apps" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.send_command(:delete, 'all')
+    subject.applications.should be_empty
+  end
+
   describe "command" do
     it "should send_command" do
       mock(Eye::Control).send_command(:restart, 'samples')

data/spec/controller/find_objects_spec.rb

@@ -67,6 +67,12 @@ describe "find_objects" do
     objs.map{|c| c.name}.sort.should == %w{app1 app2}
   end
 
+  it "'*', find all projects" do
+    objs = subject.find_objects("*")
+    objs.map{|c| c.class}.should == [Eye::Application, Eye::Application]
+    objs.map{|c| c.name}.sort.should == %w{app1 app2}
+  end
+
   it "nothing" do
     subject.find_objects("asdfasdf").should == []
   end

data/spec/controller/intergration_spec.rb

@@ -166,6 +166,30 @@ describe "Intergration" do
       # nothing happens
       @samples.alive?.should == true
     end
+
+    it "chain breaker breaks current chain and all pending requests" do
+      @samples.config.merge!(:chain => C.restart_async)
+
+      @c.send_command(:restart, "samples")
+      @c.send_command(:stop, "samples")
+      sleep 0.5
+
+      @samples.current_scheduled_command.should == :restart
+      @samples.scheduler_actions_list.should == [:stop]
+
+      @c.send_command(:break_chain, "samples")
+      sleep 3
+      @samples.current_scheduled_command.should == :restart
+      sleep 2
+      @samples.current_scheduled_command.should == nil
+      @samples.scheduler_actions_list.should == []
+
+      sleep 1
+
+      # only first process should be restarted
+      @p1.last_scheduled_command.should == :restart
+      @p2.last_scheduled_command.should == :monitor
+    end
   end
 
   it "stop group" do

data/spec/dsl/checks_spec.rb

@@ -73,7 +73,7 @@ describe "Eye::Dsl checks" do
         end        
       end
     E
-    expect{Eye::Dsl.parse_apps(conf)}.to raise_error(Eye::Checker::Validation::Error)
+    expect{Eye::Dsl.parse_apps(conf)}.to raise_error(Eye::Dsl::Validation::Error)
   end
 
   it "ok trigger" do
@@ -98,7 +98,7 @@ describe "Eye::Dsl checks" do
         end        
       end
     E
-    expect{Eye::Dsl.parse_apps(conf)}.to raise_error(Eye::Checker::Validation::Error)
+    expect{Eye::Dsl.parse_apps(conf)}.to raise_error(Eye::Dsl::Validation::Error)
   end
 
   it "nochecks to remove inherit checks" do

data/spec/dsl/notify_spec.rb

@@ -56,7 +56,7 @@ describe "Eye::Dsl notify" do
   it "raise on unknown contact type" do
     conf = <<-E
       Eye.config do
-        contact :vasya, :dddd, "vasya@mail.ru"
+        contact :vasya, :dddd, "vasya@mail.ru", :host => "localhost", :port => 12
       end
     E
     expect{ Eye::Dsl.parse(conf) }.to raise_error(Eye::Dsl::Error)
@@ -65,10 +65,19 @@ describe "Eye::Dsl notify" do
   it "raise on unknown additional_options" do
     conf = <<-E
       Eye.config do
-        contact :vasya, :mail, "vasya@mail.ru", :bla => 1
+        contact :vasya, :mail, "vasya@mail.ru", :host => "localhost", :port => 12, :bla => 1
       end
     E
-    expect{ Eye::Dsl.parse(conf) }.to raise_error(Eye::Checker::Validation::Error)
+    expect{ Eye::Dsl.parse(conf) }.to raise_error(Eye::Dsl::Validation::Error)
+  end
+
+  it "raise on not including on list of values" do
+    conf = <<-E
+      Eye.config do
+        contact :vasya, :mail, "vasya@mail.ru", :host => "localhost", :port => 12, :auth => :ply
+      end
+    E
+    expect{ Eye::Dsl.parse(conf) }.to raise_error(Eye::Dsl::Validation::Error)
   end
 
   it "set notify inherited" do

data/spec/dsl/with_server_spec.rb

@@ -38,6 +38,28 @@ describe "with_server feature" do
     Eye::Dsl.parse_apps(conf).should == {"bla"=>{:name => "bla", :groups=>{"__default__"=>{:name => "__default__", :application => "bla", :processes=>{"1"=>{:pid_file=>"1.pid", :application=>"bla", :group=>"__default__", :name=>"1"}}}}}}
   end
 
+  it "should behaves like scoped" do
+    stub(Eye::System).host{ "server1" }
+
+    conf = <<-E
+      Eye.application("bla") do
+        env "A" => "B"
+        with_server /server1/ do
+          env "A" => "C"
+          group(:a){}
+        end
+
+        group(:b){}
+      end
+    E
+
+    Eye::Dsl.parse_apps(conf).should == {
+      "bla" => {:name=>"bla", :environment=>{"A"=>"B"}, 
+        :groups=>{
+          "a"=>{:name=>"a", :environment=>{"A"=>"C"}, :application=>"bla", :processes=>{}}, 
+          "b"=>{:name=>"b", :environment=>{"A"=>"B"}, :application=>"bla", :processes=>{}}}}}
+  end
+
   describe "matches" do
     subject{ Eye::Dsl::Opts.new }
 
@@ -80,11 +102,13 @@ describe "with_server feature" do
       conf = <<-E
         Eye.application("bla"){ 
           with_server('mega_server') do
-            working_dir "/tmp"
+            group :blo do
+              working_dir "/tmp"
+            end            
           end
         }
       E
-      Eye::Dsl.parse_apps(conf).should == {"bla" => {:working_dir=>"/tmp", :name => "bla"}}
+      Eye::Dsl.parse_apps(conf).should == {"bla" => {:name=>"bla", :groups=>{"blo"=>{:name=>"blo", :application=>"bla", :working_dir=>"/tmp", :processes=>{}}}}}
     end
 
     it "hostname work" do

data/spec/process/checks/child_checks_spec.rb

@@ -70,7 +70,7 @@ describe "ChildProcess" do
 
 
       crazy.watchers.keys.should == [:check_memory, :check_cpu]
-      mock(crazy).notify(:crit, "Bounded cpu(50%): [*55%, *55%]")
+      mock(crazy).notify(:crit, "Bounded cpu(50%): [*55%, *55%] send to :restart")
       mock(crazy).schedule :restart, anything
 
       sleep 4

data/spec/process/checks/memory_spec.rb

@@ -37,6 +37,20 @@ describe "Process Memory check" do
       sleep 1
     end
 
+    it "when memory exceed limit process should stop if fire==stop" do
+      @check = {:memory => {:every => 2, :below => 40.megabytes, :times => 1, :type => :memory, :fire => :stop}}
+      start_ok_process(@c.merge(:checks => @check))
+      stub(Eye::SystemResources).memory(@process.pid){ 20_000 }
+
+      sleep 3
+
+      stub(Eye::SystemResources).memory(@process.pid){ 50_000 }      
+      mock(@process).notify(:crit, anything)
+      mock(@process).schedule(:stop, anything)
+
+      sleep 1
+    end
+
     it "else should not restart" do
       start_ok_process(@c.merge(:checks => @check))
 

data/spec/process/scheduler_spec.rb

@@ -122,6 +122,14 @@ describe "Scheduler" do
     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

data/spec/process/system_spec.rb

@@ -4,7 +4,7 @@ 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
@@ -16,6 +16,17 @@ describe "Eye::Process::System" do
     @process.load_pid_from_file.should == nil
   end
 
+  it "failsafe_load_pid" do
+    File.open(@process[:pid_file_ex], 'w'){|f| f.write("asdf") }
+    @process.failsafe_load_pid.should == nil
+
+    File.open(@process[:pid_file_ex], 'w'){|f| f.write(12345) }
+    @process.failsafe_load_pid.should == 12345
+
+    FileUtils.rm(@process[:pid_file_ex]) rescue nil    
+    @process.failsafe_load_pid.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
@@ -29,6 +40,18 @@ describe "Eye::Process::System" do
     File.read(@process[:pid_file_ex]).to_i.should == 123456789
   end
 
+  it "failsafe_save_pid ok case" do
+    @process.pid = 123456789
+    @process.failsafe_save_pid.should == true
+    File.read(@process[:pid_file_ex]).to_i.should == 123456789
+  end
+
+  it "failsafe_save_pid bad case" do
+    @process.config[:pid_file_ex] = "/asdf/adf/asd/fs/dfs/das/df.1"
+    @process.pid = 123456789
+    @process.failsafe_save_pid.should == false    
+  end
+
   it "clear_pid_file" do
     @process.pid = 123456789
     @process.save_pid_to_file
@@ -46,16 +69,16 @@ describe "Eye::Process::System" do
     @process.process_realy_running?.should == nil
 
     @process.pid = -123434
-    @process.process_realy_running?.should == false
+    @process.process_realy_running?.should == nil
   end
 
   it "send_signal ok" do
-    mock(Eye::System).send_signal(@process.pid, :TERM){ {:status => :ok} }
+    mock(Eye::System).send_signal(@process.pid, :TERM){ {:result => :ok} }
     @process.send_signal(:TERM).should == true
   end
 
   it "send_signal not ok" do
-    mock(Eye::System).send_signal(@process.pid, :TERM){ {:status => :error} }
+    mock(Eye::System).send_signal(@process.pid, :TERM){ {:error => Exception.new('bla')} }
     @process.send_signal(:TERM).should == false
   end
 

data/spec/spec_helper.rb

@@ -4,7 +4,9 @@ require 'celluloid'
 
 if ENV['COV']
   require 'simplecov'
-  SimpleCov.start 
+  SimpleCov.start do
+    add_filter "/bundle/"
+  end
 end
 
 Bundler.require :default