eye 0.1.11 → 0.2

data/lib/eye/process/commands.rb

@@ -72,21 +72,8 @@ module Eye::Process::Commands
     switch :restarting
 
     if self[:restart_command]
-      cmd = prepare_command(self[:restart_command])
-      info "executing: `#{cmd}` with restart_timeout: #{self[:restart_timeout].to_f}s and restart_grace: #{self[:restart_grace].to_f}s"
-
-      res = execute(cmd, config.merge(:timeout => self[:restart_timeout]))
-
-      if res[:error]
-        error "restart raised with #{res[:error].inspect}"
-
-        if res[:error].class == Timeout::Error
-          error 'you should tune restart_timeout setting'
-        end
-      end
-
-      sleep self[:restart_grace].to_f
-
+      execute_restart_command
+      sleep self[:restart_timeout].to_f
       result = check_alive_with_refresh_pid_if_needed
       switch(result ? :restarted : :crushed)
     else
@@ -122,7 +109,7 @@ private
       sleep self[:stop_grace].to_f
 
     elsif self[:stop_signals]
-      info "executing signals `#{self[:stop_signals].inspect}`"
+      info "executing stop_signals #{self[:stop_signals].inspect}"
       stop_signals = self[:stop_signals].clone
 
       signal = stop_signals.shift
@@ -132,8 +119,7 @@ private
         delay = stop_signals.shift
         signal = stop_signals.shift
 
-        sleep(delay.to_f)
-        unless process_realy_running?
+        if wait_for_condition(delay.to_f, 0.1){ !process_realy_running? }
           info 'has terminated'
           break
         end
@@ -157,6 +143,23 @@ private
       end
     end
   end
+
+  def execute_restart_command
+    cmd = prepare_command(self[:restart_command])
+    info "executing: `#{cmd}` with restart_timeout: #{self[:restart_timeout].to_f}s and restart_grace: #{self[:restart_grace].to_f}s"
+
+    res = execute(cmd, config.merge(:timeout => self[:restart_timeout]))
+
+    if res[:error]
+      error "restart raised with #{res[:error].inspect}"
+
+      if res[:error].class == Timeout::Error
+        error 'you should tune restart_timeout setting'
+      end
+    end
+
+    res
+  end
   
   def daemonize_process
     time_before = Time.now

data/lib/eye/process/notify.rb

@@ -1,17 +1,32 @@
 module Eye::Process::Notify
 
   # notify to user:
-  # 1) process crushed by itself, and we restart it
-  # 2) checker fire to restart process +
-  # 3) flapping + switch to unmonitored
+  # 1) process crushed by itself, and we restart it [:warn]
+  # 2) checker bounded to restart process [:crit]
+  # 3) flapping + switch to unmonitored [:crit]
 
-  # level = [:warn, :crit]
+  LEVELS = {:warn => 0, :crit => 1}
 
-  # TODO: add mail, jabber here
   def notify(level, msg)
-    if level != :warn
-      warn "!!!!!!!! NOTIFY: #{level}, #{msg} !!!!!!!!!!!"
+    # logging it
+    error "NOTIFY: #{msg}" if ilevel(level) > 0
+
+    # send notifies
+    if self[:notify].present?
+      message = {:message => msg, :name => name, 
+        :full_name => full_name, :pid => pid, :host => Eye::System.host, :level => level,
+        :at => Time.now }
+
+      self[:notify].each do |contact, not_level|
+        Eye::Notify.notify(contact, message) if ilevel(level) >= ilevel(not_level)
+      end
     end
   end
 
+private
+
+  def ilevel(level)
+    LEVELS[level].to_i
+  end
+
 end

data/lib/eye/process/system.rb

@@ -47,14 +47,27 @@ module Eye::Process::System
     res[:status] == :ok
   end
 
-  def with_timeout(time, &block)
-    Timeout.timeout(time.to_f, &block)
-  rescue Timeout::Error
-    :timeout
+  # non blocking actor timeout
+  def wait_for_condition(timeout, step = 0.1, &block)
+    defer{ wait_for_condition_sync(timeout, step, &block) }
   end
 
   def execute(cmd, cfg = {})
     defer{ Eye::System::execute cmd, cfg }
   end
-  
+
+private
+
+  def wait_for_condition_sync(timeout, step, &block)
+    res = nil
+
+    Timeout::timeout(timeout.to_f) do
+      sleep step.to_f until res = yield
+    end
+
+    res
+  rescue Timeout::Error
+    false
+  end
+
 end

data/lib/eye/process/validate.rb

@@ -0,0 +1,23 @@
+require 'shellwords'
+
+module Eye::Process::Validate
+
+  class Error < Exception; end
+
+  def validate(config)
+    if (str = config[:start_command])
+      # it should parse with Shellwords and not raise
+      spl = Shellwords.shellwords(str) * '#'
+
+      if config[:daemonize]
+        if spl =~ %r[sh#\-c|#&&#|;#]
+          raise Error, "#{config[:name]}, start_command in daemonize not supported shell concats like '&&'"
+        end
+      end
+    end
+
+    Shellwords.shellwords(config[:stop_command]) if config[:stop_command]
+    Shellwords.shellwords(config[:restart_command]) if config[:restart_command]
+  end
+
+end

data/lib/eye/system.rb

@@ -67,11 +67,14 @@ module Eye::System
       {:pid => pid}
 
     rescue Timeout::Error => ex      
-      send_signal(pid, 9)
+      send_signal(pid, 9) if pid
       {:error => ex}
 
     rescue Errno::ENOENT, Errno::EACCES => ex
       {:error => ex}
+
+    ensure 
+      Process.detach(pid) if pid
     end
 
     # get table

data/lib/eye/utils.rb

@@ -2,4 +2,13 @@ module Eye::Utils
   autoload :Tail,           'eye/utils/tail'
   autoload :AliveArray,     'eye/utils/alive_array'
   autoload :CelluloidChain, 'eye/utils/celluloid_chain'
+
+  def self.deep_clone(value)
+    case
+      when value.is_a?(Array) then value.map{|v| deep_clone(v) }
+      when value.is_a?(Hash) then value.inject({}){|r, (k, v)| r[ deep_clone(k) ] = deep_clone(v); r }
+      else value
+    end
+  end
+    
 end

data/spec/checker_spec.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 require File.dirname(__FILE__) + '/spec_helper'
 
 class Checker1 < Eye::Checker

data/spec/client_server_spec.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe "Eye::Client, Eye::Server" do

data/spec/controller/controller_spec.rb

@@ -94,7 +94,7 @@ S
 
   it "info_string_debug should be" do
     subject.load(fixture("dsl/load.eye"))
-    subject.info_string_debug.split("\n").size.should > 10
+    subject.info_string_debug.split("\n").size.should > 5
   end
 
   it "info_string_short should be" do

data/spec/controller/intergration_spec.rb

@@ -78,6 +78,21 @@ describe "Intergration" do
     @p3.last_scheduled_reason.should == 'restart by user'
   end
 
+  it "restart forking named child" do
+    @p3.childs.size.should == 3
+    dead_pid = @p3.childs.keys.sample
+
+    @c.send_command(:restart, "child-#{dead_pid}").should == ["int:forking:child-#{dead_pid}"]
+    sleep 11 # while it
+
+    new_childs = @p3.childs.keys
+    new_childs.size.should == 3
+    new_childs.should_not include(dead_pid)
+    (@childs - [dead_pid]).each do |pid|
+      new_childs.should include(pid)
+    end
+  end
+
   it "restart missing" do
     @old_pid1 = @p1.pid
     @old_pid2 = @p2.pid

data/spec/controller/load_spec.rb

@@ -308,19 +308,64 @@ describe "Eye::Controller::Load" do
 
   describe "load is exclusive" do
     it "run double in time" do
-      t = Time.now
       Eye::Control.async.command(:load, fixture("dsl/long_load.eye"))
       Eye::Control.async.command(:load, fixture("dsl/long_load.eye"))
-      sleep 2.5      
-      Eye::Control.command(:info).should be_a(String) # actor should free here
+      sleep 2.5   
+      should_spend(0, 0.2) do
+        Eye::Control.command(:info).should be_a(String)
+      end
     end
 
     it "load with subloads" do
       silence_warnings{ 
         Eye::Control.command(:load, fixture("dsl/subfolder2.eye"))
       }
-      Eye::Control.command(:info).should be_a(String) # actor should free here
+      should_spend(0, 0.2) do
+        Eye::Control.command(:info).should be_a(String)
+      end
     end
   end
 
+  describe "cleanup configs on delete" do
+    it "load config, delete 1 process, load another config" do
+      subject.load(fixture('dsl/load.eye')) 
+      subject.process_by_name('p1').should be
+
+      subject.command(:delete, "p1"); sleep 0.1
+      subject.process_by_name('p1').should be_nil
+
+      subject.load(fixture('dsl/load2.eye')) 
+      subject.process_by_name('p1').should be_nil      
+    end
+
+    it "load config, delete 1 group, load another config" do
+      subject.load(fixture('dsl/load.eye')) 
+      subject.group_by_name('gr1').should be
+
+      subject.command(:delete, "gr1"); sleep 0.1
+      subject.group_by_name('p1').should be_nil
+
+      subject.load(fixture('dsl/load2.eye')) 
+      subject.group_by_name('gr1').should be_nil      
+    end
+
+    it "load config, then delete app, and load it with changed app-name" do
+      subject.load(fixture('dsl/load3.eye')) 
+      subject.command(:delete, "app3"); sleep 0.1
+      subject.load(fixture('dsl/load4.eye')).should include(error: false)
+    end
+  end
+
+  it "should update only changed apps" do
+    mock(subject).update_or_create_application('app1', is_a(Hash))
+    mock(subject).update_or_create_application('app2', is_a(Hash))
+    subject.load(fixture('dsl/load.eye'))
+
+    mock(subject).update_or_create_application('app3', is_a(Hash))
+    subject.load(fixture('dsl/load2.eye'))    
+
+    mock(subject).update_or_create_application('app3', is_a(Hash))
+    subject.load(fixture('dsl/load3.eye'))
+  end
+
 end

data/spec/dsl/chain_spec.rb

@@ -10,28 +10,34 @@ describe "Eye::Dsl::Chain" do
         process("3") do
           pid_file "3"
         end
+
+        group :yy do
+        end
       end
     E
-    
+
     h = {
-      "bla" => {:name => "bla",
-        :chain=>{
-          :start=>{:grace=>5, :action=>:start}, 
-          :restart=>{:grace=>5, :action=>:restart}}, 
+      "bla" => {
+        :name=>"bla", 
+        :chain=>{:start=>{:grace=>5, :action=>:start}, :restart=>{:grace=>5, :action=>:restart}}, 
         :groups=>{
-          "__default__"=>{:name => "__default__", :application => "bla",
-            :chain=>{
-              :start=>{:grace=>5, :action=>:start}, 
-              :restart=>{:grace=>5, :action=>:restart}}, 
+          "__default__"=>{
+            :name=>"__default__", 
+            :chain=>{:start=>{:grace=>5, :action=>:start}, :restart=>{:grace=>5, :action=>:restart}}, 
+            :application=>"bla", 
             :processes=>{
               "3"=>{
-                :chain=>{:start=>{:grace=>5, :action=>:start}, 
-                :restart=>{:grace=>5, :action=>:restart}}, 
-                :pid_file=>"3", 
+                :name=>"3", 
+                :chain=>{:start=>{:grace=>5, :action=>:start}, :restart=>{:grace=>5, :action=>:restart}}, 
                 :application=>"bla", 
                 :group=>"__default__", 
-                :name=>"3"}}}}}}
-
+                :pid_file=>"3"}}}, 
+              "yy"=>{
+                :name=>"yy", 
+                :chain=>{:start=>{:grace=>5, :action=>:start}, :restart=>{:grace=>5, :action=>:restart}}, 
+                :application=>"bla", :processes=>{}}}}
+    }
+    
     Eye::Dsl.parse_apps(conf).should == h
   end
 

data/spec/dsl/checks_spec.rb

@@ -191,12 +191,29 @@ describe "Eye::Dsl checks" do
 
           checks :socket, :addr => "unix:/tmp/1", :expect_data => Proc.new{|data| data == 1}
         end        
+
+        process("3") do
+          pid_file "3.pid"
+
+          checks :socket, :addr => "unix:/tmp/3", :expect_data => /regexp/
+        end        
+
+        process("2") do
+          pid_file "2.pid"
+
+          checks :socket, :addr => "unix:/tmp/2", :expect_data => Proc.new{|data| data == 1}
+        end        
+
       end
     E
     res = Eye::Dsl.parse_apps(conf)
     proc = res['bla'][:groups]['__default__'][:processes]['1'][:checks][:socket][:expect_data]
     proc[0].should == false
     proc[1].should == true
+
+    proc = res['bla'][:groups]['__default__'][:processes]['2'][:checks][:socket][:expect_data]
+    proc[0].should == false
+    proc[1].should == true
   end
 
 end

data/spec/dsl/notify_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Eye::Dsl notify" do
+  it "integration" do
+    conf = <<-E
+      Eye.config do
+        mail :host => "mx.some.host.ru", :port => 25
+
+        contact :vasya, :mail, "vasya@mail.ru"
+        contact :petya, :mail, "petya@mail.ru", :port => 1111
+
+        contact_group :idiots do
+          contact :idiot1, :mail, "idiot1@mail.ru"
+          contact :idiot2, :mail, "idiot1@mail.ru", :port => 1111
+        end
+      end
+
+      Eye.application :bla do
+        notify :vasya
+        notify :idiots, :crit
+
+        group :gr1 do
+          notify :petya
+          notify :idiot1, :warn
+        end
+      end
+    E
+    res = Eye::Dsl.parse(conf)
+
+    res.should == {
+      :applications => {
+        "bla"=>{:name=>"bla", 
+          :notify=>{"vasya"=>:crit, "idiots"=>:crit}, 
+          :groups=>{"gr1"=>{:name=>"gr1", 
+            :notify=>{"vasya"=>:crit, "idiots"=>:crit, "petya"=>:crit, "idiot1"=>:warn}, :application=>"bla", :processes=>{}}}}},
+      :config => {
+        :mail=>{:host=>"mx.some.host.ru", :port => 25, :type => :mail}, 
+        :contacts=>{
+          "vasya"=>{:name=>"vasya", :type=>:mail, :contact=>"vasya@mail.ru", :opts=>{}}, 
+          "petya"=>{:name=>"petya", :type=>:mail, :contact=>"petya@mail.ru", :opts=>{:port=>1111}}, 
+          'idiots'=>[{:name=>"idiot1", :type=>:mail, :contact=>"idiot1@mail.ru", :opts=>{}}, {:name=>"idiot2", :type=>:mail, :contact=>"idiot1@mail.ru", :opts=>{:port=>1111}}], 
+          "idiot1"=>{:name=>"idiot1", :type=>:mail, :contact=>"idiot1@mail.ru", :opts=>{}}, 
+          "idiot2"=>{:name=>"idiot2", :type=>:mail, :contact=>"idiot1@mail.ru", :opts=>{:port=>1111}}}}}
+  end
+
+  it "valid contact type" do
+    conf = <<-E
+      Eye.config do
+        contact :vasya, :mail, "vasya@mail.ru", :port => 25, :host => "localhost"
+      end
+    E
+    Eye::Dsl.parse(conf)[:config].should == {:contacts=>{
+      "vasya"=>{:name=>"vasya", :type=>:mail, :contact=>"vasya@mail.ru", :opts=>{:port => 25, :host => "localhost"}}}}
+  end
+
+  it "raise on unknown contact type" do
+    conf = <<-E
+      Eye.config do
+        contact :vasya, :dddd, "vasya@mail.ru"
+      end
+    E
+    expect{ Eye::Dsl.parse(conf) }.to raise_error(Eye::Dsl::Error)
+  end
+
+  it "raise on unknown additional_options" do
+    conf = <<-E
+      Eye.config do
+        contact :vasya, :mail, "vasya@mail.ru", :bla => 1
+      end
+    E
+    expect{ Eye::Dsl.parse(conf) }.to raise_error(Eye::Checker::Validation::Error)
+  end
+
+  it "set notify inherited" do
+    conf = <<-E
+      Eye.app :bla do
+        notify :vasya
+
+        group :bla do
+        end
+      end
+    E
+    Eye::Dsl.parse_apps(conf).should == {
+      "bla" => {:name=>"bla", 
+        :notify=>{"vasya"=>:crit}, 
+        :groups=>{"bla"=>{:name=>"bla", 
+          :notify=>{"vasya"=>:crit}, :application=>"bla", :processes=>{}}}}}
+  end
+
+  it "clear notify with nonotify" do
+    conf = <<-E
+      Eye.app :bla do
+        notify :vasya
+
+        group :bla do
+          nonotify :vasya
+        end
+      end
+    E
+    Eye::Dsl.parse_apps(conf).should == {
+      "bla" => {:name=>"bla", 
+        :notify=>{"vasya"=>:crit}, 
+        :groups=>{"bla"=>{:name=>"bla", :notify=>{}, :application=>"bla", :processes=>{}}}}}
+  end
+end