eye 0.4 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a4ce0513f92a734194ec12a2c10aa8cadcfaafa
-  data.tar.gz: 43e96f1ccc671f83454d790d8e546785b3cb8c18
+  metadata.gz: a1b6bc63e403f70e9de31aeedabd8712ed291fbf
+  data.tar.gz: 9c0d9241079bd13bff558852a5cd71c404f1b50e
 SHA512:
-  metadata.gz: 780ee7abb50e1a473614d33e132ccbea9854cdf4e7f5b5ca77ee003caebcddf2759f2d6ae489f7585a915b8630d3813f60924e2762c224bd2f65ad51defcaddb
-  data.tar.gz: 26b46e22aeddce190a889072e88d41bb1d638db3147c6fe4cd79d6861ac5e11063de82deb0fa5e78ee34a8c106c2592c05db11748ff7569e6e0e2f7df2d95661
+  metadata.gz: c86cba4c4a63f6febe9bad36d7f4696f766a8695129eef747518b2edad3e48a48d2d13523ba65d92ea8b346446cf50976e7b2e45ee3c143e5b4a1ce617880605
+  data.tar.gz: 5f760e64c45443a4429a127736770a1f66a31d61b56347c69c61242fdf7f28b427f0d995af0b5dd054c327bf99422150b9ee9033dde04fcce06b73143062451d

data/CHANGES.md

@@ -1,4 +1,13 @@
-0.4.dev
+0.4.1.dev
+---------
+* add nop checker for periodic restart
+* catch errors in custom checkers, triggers
+* add custom notify
+* checker can fires array of commands
+* fix targets matching
+* remove autoset PWD env
+
+0.4
 ---------
 * pass tests on 1.9.2
 * relax activesupport dependency

data/README.md

@@ -4,7 +4,7 @@ Eye
 [![Build Status](https://secure.travis-ci.org/kostya/eye.png?branch=master)](http://travis-ci.org/kostya/eye)
 [![Coverage Status](https://coveralls.io/repos/kostya/eye/badge.png?branch=master)](https://coveralls.io/r/kostya/eye?branch=master)
 
-Process monitoring tool. An alternative to God and Bluepill. With Bluepill like config syntax. Requires MRI Ruby >= 1.9.3-p194. Uses Celluloid and Celluloid::IO.
+Process monitoring tool. Inspired from Bluepill and God. Requires Ruby(MRI) >= 1.9.3-p194. Uses Celluloid and Celluloid::IO.
 
 Little demo, shows general commands and how chain works:
 
@@ -36,8 +36,8 @@ Eye.application "test" do
   working_dir File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
   stdall "trash.log" # stdout,err logs for processes by default
   env "APP_ENV" => "production" # global env for each processes
-  triggers :flapping, :times => 10, :within => 1.minute, :retry_in => 10.minutes
-  checks :cpu, :below => 100, :times => 3 # global check for all processes
+  trigger :flapping, :times => 10, :within => 1.minute, :retry_in => 10.minutes
+  check :cpu, :below => 100, :times => 3 # global check for all processes
 
   group "samples" do
     chain :grace => 5.seconds # chained start-restart with 5s interval, one by one.
@@ -53,7 +53,7 @@ Eye.application "test" do
       daemonize true
       stdall "sample1.log"
 
-      checks :cpu, :below => 30, :times => [3, 5]
+      check :cpu, :below => 30, :times => [3, 5]
     end
 
     # self daemonized process
@@ -62,7 +62,7 @@ Eye.application "test" do
       start_command "ruby ./sample.rb -d --pid 2.pid --log sample2.log"
       stop_command "kill -9 {PID}"
 
-      checks :memory, :below => 300.megabytes, :times => 3
+      check :memory, :below => 300.megabytes, :times => 3
     end
   end
 
@@ -73,12 +73,12 @@ Eye.application "test" do
     stop_command "ruby forking.rb stop"
     stdall "forking.log"
 
-    start_timeout 5.seconds
-    stop_grace 5.seconds
+    start_timeout 10.seconds
+    stop_timeout 5.seconds
 
     monitor_children do
       restart_command "kill -2 {PID}" # for this child process
-      checks :memory, :below => 300.megabytes, :times => 3
+      check :memory, :below => 300.megabytes, :times => 3
     end
   end
 
@@ -90,8 +90,8 @@ Eye.application "test" do
     daemonize true
     stop_signals [:QUIT, 2.seconds, :KILL]
 
-    checks :socket, :addr => "tcp://127.0.0.1:33221", :every => 10.seconds, :times => 2,
-                    :timeout => 1.second, :send_data => "ping", :expect_data => /pong/
+    check :socket, :addr => "tcp://127.0.0.1:33221", :every => 10.seconds, :times => 2,
+                   :timeout => 1.second, :send_data => "ping", :expect_data => /pong/
   end
 
   # thin process, self daemonized
@@ -100,14 +100,14 @@ Eye.application "test" do
     start_command "bundle exec thin start -R thin.ru -p 33233 -d -l thin.log -P thin.pid"
     stop_signals [:QUIT, 2.seconds, :TERM, 1.seconds, :KILL]
 
-    checks :http, :url => "http://127.0.0.1:33233/hello", :pattern => /World/, :every => 5.seconds,
-                  :times => [2, 3], :timeout => 1.second
+    check :http, :url => "http://127.0.0.1:33233/hello", :pattern => /World/, :every => 5.seconds,
+                 :times => [2, 3], :timeout => 1.second
   end
 
 end
 ```
 
-### Start monitoring and load config:
+### Start eye daemon and/or load config:
 
     $ eye l(oad) examples/test.eye
 
@@ -116,8 +116,11 @@ load folder with configs:
     $ eye l examples/
     $ eye l examples/*.rb
 
-Load also uses for config synchronization and load new application into runned eye daemon. Light operation, so i recommend to use with every deploy (and than restart processes).
-(for processes with option `stop_on_delete`, `load` becomes a tool for full config synchronization, which stopps deleted from config processes).
+foregraund load:
+
+    $ eye l CONF -f
+
+If eye daemon already started and you call `load` command, config will be updated (into eye daemon). New objects(applications, groups, processes) will be added and monitored. Removed from config processes will be removed (and stopped if process has `stop_on_delete true`). Other objects update their configs.
 
 
 Process statuses:
@@ -171,6 +174,22 @@ Quit monitoring:
 
     $ eye q(uit)
 
-### Config options:
+Interactive info:
+
+    $ eye w(atch)
+
+Process statuses history:
+
+    $ eye hi(story)
+
+Eye daemon info:
+
+    $ eye x(info)
+    $ eye x -c # for show current config
+
+Process states and events:
+
+[![Eye](https://raw.github.com/kostya/stuff/master/eye/mprocess.png)](https://raw.github.com/kostya/stuff/master/eye/process.png)
+
 
-  Waiting for pull requests here..., until that you can read `examples` and `spec/dsl` folders.
+Thanks `Bluepill` for the nice config ideas.

data/bin/eye

@@ -160,7 +160,7 @@ private
     res = _cmd(cmd, *args)
 
     if res == :not_started
-      error! "eye monitoring not found, did you start it?"
+      error! "socket(#{Eye::Settings.socket_path}) not found, did you `eye load`?"
     elsif res == :timeouted
       error! "eye does not answer, timeouted..."
     end

data/examples/process_thin.rb

@@ -23,7 +23,7 @@ def thin(proxy, port)
 
     stdall "thin.stdall.log"
 
-    checks :http, :url => "http://127.0.0.1:#{port}/hello", :pattern => /World/,
-                  :every => 5.seconds, :times => [2, 3], :timeout => 1.second
+    check :http, :url => "http://127.0.0.1:#{port}/hello", :pattern => /World/,
+                 :every => 5.seconds, :times => [2, 3], :timeout => 1.second
   end
 end

data/examples/puma.eye

@@ -1,34 +1,29 @@
-RUBY      = '/usr/local/ruby/1.9.3-p392/bin/ruby'
+BUNDLE = 'bundle'
 RAILS_ENV = 'production'
-ROOT      = File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
-CURRENT   = File.expand_path(File.join(ROOT, %w{current}))
-LOGS      = File.expand_path(File.join(ROOT, %w{shared log}))
-PIDS      = File.expand_path(File.join(ROOT, %w{shared pids}))
+ROOT = File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
 
 Eye.config do
-  logger "#{LOGS}/eye.log"
-  logger_level Logger::ERROR
+  logger "#{ROOT}/eye.log"
 end
 
-Eye.application :super_app do
+Eye.application :puma do
   env 'RAILS_ENV' => RAILS_ENV
   working_dir ROOT
-  triggers :flapping, :times => 10, :within => 1.minute
+  trigger :flapping, :times => 10, :within => 1.minute
 
   process :puma do
     daemonize true
-    pid_file "#{PIDS}/puma.pid"
-    stdall "#{LOGS}/#{RAILS_ENV}.log"
+    pid_file "puma.pid"
+    stdall "puma.log"
 
-    start_command "#{RUBY} bin/puma --port 80 --pidfile #{PIDS}/puma.pid --environment #{RAILS_ENV} config.ru"
-    stop_command "kill -TERM {{PID}}"
+    start_command "#{BUNDLE} exec puma --port 33280 --environment #{RAILS_ENV} thin.ru"
+    stop_signals [:TERM, 5.seconds, :KILL]
     restart_command "kill -USR2 {{PID}}"
 
-    start_timeout 15.seconds
-    stop_grace 10.seconds
-    restart_grace 10.seconds
+    restart_grace 10.seconds # just sleep this until process get up status
+                             # (maybe enought to puma soft restart)
 
-    checks :cpu, :every => 30, :below => 80, :times => 3
-    checks :memory, :every => 30, :below => 70.megabytes, :times => [3,5]
+    check :cpu, :every => 30, :below => 80, :times => 3
+    check :memory, :every => 30, :below => 70.megabytes, :times => [3,5]
   end
 end

data/examples/sidekiq.eye

@@ -10,8 +10,8 @@ def sidekiq_process(proxy, name)
     daemonize true
     stop_signals [:QUIT, 5.seconds, :TERM, 5.seconds, :KILL]
 
-    checks :cpu, :every => 30, :below => 100, :times => 5
-    checks :memory, :every => 30, :below => 300.megabytes, :times => 5
+    check :cpu, :every => 30, :below => 100, :times => 5
+    check :memory, :every => 30, :below => 300.megabytes, :times => 5
   end
 end
 

data/examples/test.eye

@@ -14,8 +14,8 @@ Eye.application "test" do
   working_dir File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
   stdall "trash.log" # stdout,err logs for processes by default
   env "APP_ENV" => "production" # global env for each processes
-  triggers :flapping, :times => 10, :within => 1.minute, :retry_in => 10.minutes
-  checks :cpu, :below => 100, :times => 3 # global check for all processes
+  trigger :flapping, :times => 10, :within => 1.minute, :retry_in => 10.minutes
+  check :cpu, :below => 100, :times => 3 # global check for all processes
 
   group "samples" do
     chain :grace => 5.seconds # chained start-restart with 5s interval, one by one.
@@ -31,7 +31,7 @@ Eye.application "test" do
       daemonize true
       stdall "sample1.log"
 
-      checks :cpu, :below => 30, :times => [3, 5]
+      check :cpu, :below => 30, :times => [3, 5]
     end
 
     # self daemonized process
@@ -40,7 +40,7 @@ Eye.application "test" do
       start_command "ruby ./sample.rb -d --pid 2.pid --log sample2.log"
       stop_command "kill -9 {PID}"
 
-      checks :memory, :below => 300.megabytes, :times => 3
+      check :memory, :below => 300.megabytes, :times => 3
     end
   end
 
@@ -51,12 +51,12 @@ Eye.application "test" do
     stop_command "ruby forking.rb stop"
     stdall "forking.log"
 
-    start_timeout 5.seconds
-    stop_grace 5.seconds
+    start_timeout 10.seconds
+    stop_timeout 5.seconds
 
     monitor_children do
       restart_command "kill -2 {PID}" # for this child process
-      checks :memory, :below => 300.megabytes, :times => 3
+      check :memory, :below => 300.megabytes, :times => 3
     end
   end
 
@@ -68,8 +68,8 @@ Eye.application "test" do
     daemonize true
     stop_signals [:QUIT, 2.seconds, :KILL]
 
-    checks :socket, :addr => "tcp://127.0.0.1:33221", :every => 10.seconds, :times => 2,
-                    :timeout => 1.second, :send_data => "ping", :expect_data => /pong/
+    check :socket, :addr => "tcp://127.0.0.1:33221", :every => 10.seconds, :times => 2,
+                   :timeout => 1.second, :send_data => "ping", :expect_data => /pong/
   end
 
   # thin process, self daemonized
@@ -78,8 +78,8 @@ Eye.application "test" do
     start_command "bundle exec thin start -R thin.ru -p 33233 -d -l thin.log -P thin.pid"
     stop_signals [:QUIT, 2.seconds, :TERM, 1.seconds, :KILL]
 
-    checks :http, :url => "http://127.0.0.1:33233/hello", :pattern => /World/, :every => 5.seconds,
-                  :times => [2, 3], :timeout => 1.second
+    check :http, :url => "http://127.0.0.1:33233/hello", :pattern => /World/, :every => 5.seconds,
+                 :times => [2, 3], :timeout => 1.second
   end
 
 end

data/examples/thin-farm.eye

@@ -14,8 +14,8 @@ Eye.app 'thin-farm' do
   stop_on_delete true # this option means, when we change pids and load config,
                       # deleted processes will be stops
 
-  triggers :flapping, :times => 10, :within => 1.minute
-  checks :memory, :below => 60.megabytes, :every => 30.seconds, :times => 5
+  trigger :flapping, :times => 10, :within => 1.minute
+  check :memory, :below => 60.megabytes, :every => 30.seconds, :times => 5
   start_timeout 30.seconds
 
   group :web do

data/examples/unicorn.eye

@@ -4,27 +4,35 @@ RUBY = '/usr/local/ruby/1.9.3/bin/ruby' # ruby on the server
 RAILS_ENV = 'production'
 
 Eye.application "rails_unicorn" do
-  env "RAILS_ENV" => RAILS_ENV, "PATH" => "#{File.dirname(RUBY)}:#{ENV['PATH']}"
+  env "RAILS_ENV" => RAILS_ENV
+
+  # unicorn requires to be `ruby` in path (for soft restart)
+  env "PATH" => "#{File.dirname(RUBY)}:#{ENV['PATH']}"
+
   working_dir File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
 
   process("unicorn") do
     pid_file "tmp/pids/unicorn.pid"
     start_command "#{RUBY} ./bin/unicorn -Dc ./config/unicorn.rb -E #{RAILS_ENV}"
-    stop_command "kill -QUIT {{PID}}"
-    restart_command "kill -USR2 {{PID}}"
     stdall "log/unicorn.log"
 
-    checks :cpu, :every => 30, :below => 80, :times => 3
-    checks :memory, :every => 30, :below => 150.megabytes, :times => [3,5]
+    # stop signals:
+    # http://unicorn.bogomips.org/SIGNALS.html
+    stop_signals [:TERM, 10.seconds]
+
+    # soft restart
+    restart_command "kill -USR2 {PID}"
+
+    check :cpu, :every => 30, :below => 80, :times => 3
+    check :memory, :every => 30, :below => 150.megabytes, :times => [3,5]
 
     start_timeout 30.seconds
-    stop_grace 5.seconds
     restart_grace 30.seconds
 
     monitor_children do
-      stop_command "kill -QUIT {{PID}}"
-      checks :cpu, :every => 30, :below => 80, :times => 3
-      checks :memory, :every => 30, :below => 150.megabytes, :times => [3,5]
+      stop_command "kill -QUIT {PID}"
+      check :cpu, :every => 30, :below => 80, :times => 3
+      check :memory, :every => 30, :below => 150.megabytes, :times => [3,5]
     end
   end
 

data/eye.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |gem|
   gem.email         = "kostya27@gmail.com"
 
   gem.description   = gem.summary = \
-    %q{Process monitoring tool. An alternative to God and Bluepill. With Bluepill like config syntax. Requires MRI Ruby >= 1.9.2. Uses Celluloid and Celluloid::IO.}
+    %q{Process monitoring tool. Inspired from Bluepill and God. Requires Ruby(MRI) >= 1.9.3-p194. Uses Celluloid and Celluloid::IO.}
   gem.homepage      = "http://github.com/kostya/eye"
 
   gem.files         = `git ls-files`.split($\).reject{|n| n =~ %r[png|gif\z]}.reject{|n| n =~ %r[^(test|spec|features)/]}

data/lib/eye.rb

@@ -1,5 +1,5 @@
 module Eye
-  VERSION   = "0.4"
+  VERSION   = "0.4.1"
   ABOUT     = "Eye v#{VERSION} (c) 2012-2013 @kostya"
   PROCLINE  = "eye monitoring v#{VERSION}"
 

data/lib/eye/application.rb

@@ -17,10 +17,6 @@ class Eye::Application
     @name
   end
 
-  def update_config(cfg)
-    @config = cfg
-  end
-
   def add_group(group)
     @groups << group
   end

data/lib/eye/checker.rb

@@ -6,16 +6,18 @@ class Eye::Checker
   autoload :FileCTime,  'eye/checker/file_ctime'
   autoload :FileSize,   'eye/checker/file_size'
   autoload :Socket,     'eye/checker/socket'
+  autoload :Nop,        'eye/checker/nop'
 
   TYPES = {:memory => "Memory", :cpu => "Cpu", :http => "Http",
-           :ctime => "FileCTime", :fsize => "FileSize", :socket => "Socket"}
+           :ctime => "FileCTime", :fsize => "FileSize", :socket => "Socket",
+           :nop => "Nop" }
 
   attr_accessor :value, :values, :options, :pid, :type, :check_count, :process
 
   extend Eye::Dsl::Validation
   param :every, [Fixnum, Float], false, 5
   param :times, [Fixnum, Array], nil, 1
-  param :fire, Symbol, nil, nil, [:stop, :restart, :unmonitor, :nothing]
+  param :fires, [Symbol, Array], nil, nil, [:stop, :restart, :unmonitor, :nothing, :start, :delete]
 
   def self.name_and_class(type)
     type = type.to_sym
@@ -35,6 +37,10 @@ class Eye::Checker
 
   def self.create(pid, options = {}, process = nil)
     get_class(options[:type]).new(pid, options, process)
+
+  rescue Exception, Timeout::Error => ex
+    log_ex(ex)
+    nil
   end
 
   def self.validate!(options)
@@ -46,6 +52,7 @@ class Eye::Checker
     @pid = pid
     @options = options
     @type = options[:type]
+    @full_name = @process.full_name if @process
 
     debug "create checker, with #{options}"
 
@@ -55,7 +62,7 @@ class Eye::Checker
   end
 
   def inspect
-    "<#{self.class} @process='#{@process.full_name}' @options=#{@options} @pid=#{@pid}>"
+    "<#{self.class} @process='#{@full_name}' @options=#{@options} @pid=#{@pid}>"
   end
 
   def logger_tag
@@ -89,6 +96,9 @@ class Eye::Checker
 
     info "#{last_human_values} => #{result ? 'OK' : 'Fail'}"
     result
+
+  rescue Exception, Timeout::Error => ex
+    log_ex(ex)
   end
 
   def get_value_safe
@@ -162,7 +172,14 @@ class Eye::Checker
     Eye::Checker.const_set(name, base)
   end
 
-  class Custom < Eye::Checker
+  class CustomCell < Eye::Checker
+    def self.inherited(base)
+      super
+      register(base)
+    end
+  end
+
+  class Custom < Defer
     def self.inherited(base)
       super
       register(base)

data/lib/eye/checker/nop.rb

@@ -0,0 +1,6 @@
+class Eye::Checker::Nop < Eye::Checker
+
+  # check :nop, :every => 10.hours # means restart every 10 hours
+
+  def get_value; end
+end

data/lib/eye/controller.rb

@@ -35,6 +35,8 @@ class Eye::Controller
 
   attr_reader :applications, :current_config
 
+  exclusive :load # load is hard command, so better to run it safely blocked
+
   def initialize
     @applications = []
     @current_config = Eye::Config.new

data/lib/eye/controller/commands.rb

@@ -8,16 +8,14 @@ module Eye::Controller::Commands
     cmd = cmd.to_sym
 
     res = case cmd
-      when :start, :stop, :restart, :unmonitor, :monitor
+      when :start, :stop, :restart, :unmonitor, :monitor, :break_chain
         send_command(cmd, *args)
       when :delete
         exclusive{ send_command(cmd, *args) }
       when :signal
         signal(*args)
-      when :break_chain
-        break_chain(*args)
       when :load
-        exclusive{ load(*args) }
+        load(*args)
       when :info
         info_string(*args)
       when :xinfo

data/lib/eye/controller/helpers.rb

@@ -10,7 +10,7 @@ module Eye::Controller::Helpers
   def save_cache
     File.open(Eye::Settings.cache_path, 'w') { |f| f.write(cache_str) }
   rescue => ex
-    warn "save cache crashed with #{ex.message}"
+    log_ex(ex)
   end
 
   def cache_str

data/lib/eye/controller/load.rb

@@ -81,7 +81,6 @@ private
 
   # return: result, config
   def parse_config(filename)
-    raise Eye::Dsl::Error, "config file '#{filename}' not found!" unless File.exists?(filename)
     debug "parse #{filename}"
 
     cfg = Eye::Dsl.parse(nil, filename)

data/lib/eye/controller/send_command.rb

@@ -23,27 +23,18 @@ module Eye::Controller::SendCommand
     end
   end
 
-  def break_chain(*args)
-    matched_objects(*args) do |obj|
-      obj.send_command(:break_chain)
-    end
-  end
-
 private
 
   class Error < Exception; end
 
   def matched_objects(*args, &block)
-    h = args.extract_options!
-    obj_strs = args
-
-    objs = find_objects(*obj_strs)
+    objs = find_objects(*args)
     res = objs.map(&:full_name)
     objs.each{|obj| block[obj] } if block
     {:result => res}
 
   rescue Error => ex
-    error ex.message
+    log_ex(ex)
 
     {:error => ex.message}
   end
@@ -69,13 +60,25 @@ private
 
   # find object to action, restart ... (app, group or process)
   # nil if not found
-  def find_objects(*obj_strs)
+  def find_objects(*args)
+    h = args.extract_options!
+    obj_strs = args
+
     return [] if obj_strs.blank?
-    return @applications.dup if obj_strs.size == 1 && (obj_strs[0].to_s.strip == 'all' || obj_strs[0].to_s.strip == '*')
+
+    if obj_strs.size == 1 && (obj_strs[0].to_s.strip == 'all' || obj_strs[0].to_s.strip == '*')
+      if h[:application]
+        return @applications.select { |app| app.name == h[:application]}
+      else
+        return @applications.dup
+      end
+    end
 
     res = Eye::Utils::AliveArray.new
     obj_strs.map{|c| c.to_s.split(",")}.flatten.each do |mask|
-      res += find_objects_by_mask(mask.to_s.strip)
+      objs = find_objects_by_mask(mask.to_s.strip)
+      objs.select! { |obj| obj.app_name == h[:application] } if h[:application]
+      res += objs
     end
     res
   end
@@ -88,9 +91,9 @@ private
 
       # try to find exactly matched
       if mask[-1] != '*'
-        r = right_regexp(mask)
+        r = exact_regexp(mask)
         res.each do |obj|
-          final << obj if obj.full_name =~ r
+          final << obj if obj.name =~ r || obj.full_name =~ r
         end
       end
 
@@ -106,16 +109,18 @@ private
       res = final
 
       # try to remove objects with different applications
-      fapps, apps = [], []
+      apps, objs = Eye::Utils::AliveArray.new, Eye::Utils::AliveArray.new
       res.each do |obj|
         if obj.is_a?(Eye::Application)
-          fapps << obj.name
+          apps << obj
         else
-          apps << obj.app_name
+          objs << obj
         end
       end
 
-      if (apps).uniq.size > 1 || (fapps.size > 0 && (apps | fapps).size > fapps.size)
+      return apps if apps.size > 0
+
+      if objs.map(&:app_name).uniq.size > 1
         raise Error, "cant match targets from different applications: #{res.map(&:full_name)}"
       end
     end
@@ -163,8 +168,8 @@ private
     %r|\A#{str}|
   end
 
-  def right_regexp(mask)
+  def exact_regexp(mask)
     str = Regexp.escape(mask).gsub('\*', '.*?')
-    %r|#{str}\z|
+    %r|\A#{str}\z|
   end
 end

data/lib/eye/controller/status.rb

@@ -17,7 +17,6 @@ About:  #{Eye::ABOUT}
 Info:   #{resources_str(Eye::SystemResources.resources($$))}
 Ruby:   #{RUBY_DESCRIPTION}
 Gems:   #{%w|Celluloid Celluloid::IO ActiveSupport StateMachine NIO|.map{|c| gem_version(c) }}
-Checks: #{Eye::Checker::TYPES}, #{Eye::Trigger::TYPES}
 Logger: #{Eye::Logger.dev}
 Socket: #{Eye::Settings::socket_path}
 Pid:    #{Eye::Settings::pid_path}

data/lib/eye/dsl/child_process_opts.rb

@@ -5,4 +5,8 @@ class Eye::Dsl::ChildProcessOpts < Eye::Dsl::Opts
       :stop_signals, :stop_grace, :stop_timeout, :restart_timeout]
   end
 
+  def triggers(*args)
+    raise Eye::Dsl::Error, "triggers does not allowed in monitor_children"
+  end
+
 end

data/lib/eye/dsl/config_opts.rb

@@ -9,17 +9,18 @@ class Eye::Dsl::ConfigOpts < Eye::Dsl::PureOpts
   end
 
   # ==== contact options ==============================
+  def self.add_notify(type)
+    create_options_methods([type], Hash)
 
-  Eye::Notify::TYPES.keys.each do |not_system|
-    create_options_methods([not_system], Hash)
-
-    define_method("set_#{not_system}") do |value|
-      value = value.merge(:type => not_system)
+    define_method("set_#{type}") do |value|
+      value = value.merge(:type => type)
       super(value)
       Eye::Notify.validate!(value)
     end
   end
 
+  Eye::Notify::TYPES.keys.each { |name| add_notify(name) }
+
   def contact(contact_name, contact_type, contact, contact_opts = {})
     raise Eye::Dsl::Error, "unknown contact_type #{contact_type}" unless Eye::Notify::TYPES[contact_type]
     raise Eye::Dsl::Error, "contact should be a String" unless contact.is_a?(String)

data/lib/eye/dsl/main.rb

@@ -11,6 +11,7 @@ module Eye::Dsl::Main
     Eye::Dsl.debug "<= app: #{name}"
   end
 
+  alias project application
   alias app application
 
   def load(glob = '')

data/lib/eye/dsl/opts.rb

@@ -87,6 +87,7 @@ class Eye::Dsl::Opts < Eye::Dsl::PureOpts
     @config[:environment].merge!(value)
   end
 
+  alias dir working_dir
   alias env environment
 
   def set_stdall(value)

data/lib/eye/dsl/validation.rb

@@ -41,8 +41,14 @@ module Eye::Dsl::Validation
       end
 
       if self.variants[param]
-        if value && !value.is_a?(Proc) && !self.variants[param].include?(value)
-          raise Error, "#{value.inspect} should within #{self.variants[param].inspect}"
+        if value && !value.is_a?(Proc)
+          if value.is_a?(Array)
+            if (value - self.variants[param]).present?
+              raise Error, "#{value.inspect} should within #{self.variants[param].inspect}"
+            end
+          elsif !self.variants[param].include?(value)
+            raise Error, "#{value.inspect} should within #{self.variants[param].inspect}"
+          end
         end
       end
 

data/lib/eye/logger.rb

@@ -33,6 +33,11 @@ class Eye::Logger
         logger.send(method_name, msg)
       end
     end
+
+    def log_ex(ex)
+      error "#{ex.message} #{ex.backtrace}"
+      # notify here?
+    end
   end
 
   Logger::Severity.constants.each do |level|

data/lib/eye/notify.rb

@@ -40,6 +40,9 @@ class Eye::Notify
     else
       create_proc[needed_hash]
     end
+
+  rescue Exception, Timeout::Error => ex
+    log_ex(ex)
   end
 
   TIMEOUT = 1.minute
@@ -81,6 +84,21 @@ class Eye::Notify
     "#{message_subject} at #{msg_at.to_s(:short)}"
   end
 
+  def self.register(base)
+    name = base.to_s.gsub("Eye::Notify::", '')
+    type = name.underscore.to_sym
+    Eye::Notify::TYPES[type] = name
+    Eye::Notify.const_set(name, base)
+    Eye::Dsl::ConfigOpts.add_notify(type)
+  end
+
+  class Custom < Eye::Notify
+    def self.inherited(base)
+      super
+      register(base)
+    end
+  end
+
 private
 
   %w{at host message name full_name pid level}.each do |name|

data/lib/eye/process/commands.rb

@@ -87,7 +87,10 @@ module Eye::Process::Commands
 private
 
   def kill_process
-    return unless self.pid
+    unless self.pid
+      error "try to kill process without pid"
+      return
+    end
 
     if self[:stop_command]
       cmd = prepare_command(self[:stop_command])
@@ -120,7 +123,7 @@ private
           break
         end
 
-        send_signal(signal)
+        send_signal(signal) if signal
       end
 
       sleep_grace(:stop_grace)
@@ -141,6 +144,11 @@ private
   end
 
   def execute_restart_command
+    unless self.pid
+      error "try to execute restart_command without pid"
+      return
+    end
+
     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"
 
@@ -219,17 +227,17 @@ private
     sleep_grace(:start_grace)
 
     unless set_pid_from_file
-      error "pid_file(#{self[:pid_file_ex]}) does not appears after start_grace #{self[:start_grace].to_f}, check start_command, or tune start_grace (eye dont know what to monitor without pid)"
+      error "exit status #{res[:exitstatus]}, pid_file(#{self[:pid_file_ex]}) does not appears after start_grace #{self[:start_grace].to_f}, check start_command, or tune start_grace (eye dont know what to monitor without pid)"
       return {:error => :pid_not_found}
     end
 
     unless process_realy_running?
-      error "process in pid_file(#{self[:pid_file_ex]})(#{self.pid}) not found, maybe process do not write there actual pid, or just crashed (#{check_logs_str})"
+      error "exit status #{res[:exitstatus]}, process in pid_file(#{self[:pid_file_ex]})(#{self.pid}) not found, maybe process do not write there actual pid, or just crashed (#{check_logs_str})"
       return {:error => :not_realy_running}
     end
 
     res[:pid] = self.pid
-    info "process get pid:#{res[:pid]}, pid_file #{self[:pid_file_ex]}"
+    info "process get pid:#{res[:pid]}, pid_file #{self[:pid_file_ex]}, exit status #{res[:exitstatus]}"
     res
   end
 

data/lib/eye/process/system.rb

@@ -86,7 +86,7 @@ module Eye::Process::System
     save_pid_to_file
     true
   rescue => ex
-    error "failsafe_save_pid: #{ex.message}"
+    log_ex(ex)
     false
   end
 

data/lib/eye/process/trigger.rb

@@ -29,7 +29,7 @@ private
 
   def add_trigger(cfg = {})
     trigger = Eye::Trigger.create(current_actor, cfg)
-    self.triggers << trigger
+    self.triggers << trigger if trigger
   end
 
 end

data/lib/eye/process/watchers.rb

@@ -53,16 +53,19 @@ private
     subject = Eye::Checker.create(pid, cfg, current_actor)
 
     # ex: {:type => :memory, :every => 5.seconds, :below => 100.megabytes, :times => [3,5]}
-    add_watcher("check_#{name}".to_sym, subject.every, subject, &method(:watcher_tick).to_proc)
+    add_watcher("check_#{name}".to_sym, subject.every, subject, &method(:watcher_tick).to_proc) if subject
   end
 
   def watcher_tick(subject)
     unless subject.check
       return unless up?
 
-      action = subject.fire || :restart
-      notify :warn, "Bounded #{subject.check_name}: #{subject.last_human_values} send to :#{action}"
-      schedule action, Eye::Reason.new("bounded #{subject.check_name}")
+      actions = subject.fires ? Array(subject.fires) : [:restart]
+      notify :warn, "Bounded #{subject.check_name}: #{subject.last_human_values} send to #{actions}"
+
+      actions.each do |action|
+        schedule action, Eye::Reason.new("bounded #{subject.check_name}")
+      end
     end
   end
 

data/lib/eye/system.rb

@@ -58,7 +58,7 @@ module Eye::System
       opts = spawn_options(cfg)
       pid  = Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), opts)
       Process.detach(pid)
-      {:pid => pid}
+      {:pid => pid, :exitstatus => 0}
 
     rescue Errno::ENOENT, Errno::EACCES => ex
       {:error => ex}
@@ -74,11 +74,14 @@ module Eye::System
       pid  = Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), opts)
 
       timeout = cfg[:timeout] || 1.second
+      status = 0
+
       Timeout.timeout(timeout) do
-        Process.waitpid(pid)
+        _, st = Process.waitpid2(pid)
+        status = st.exitstatus || st.termsig
       end
 
-      {:pid => pid}
+      {:pid => pid, :exitstatus => status}
 
     rescue Timeout::Error => ex
       if pid
@@ -156,9 +159,6 @@ module Eye::System
         env[k.to_s] = v.to_s if v
       end
 
-      # set PWD for unicorn respawn
-      env['PWD'] = config[:working_dir] if config[:working_dir]
-
       env
     end
   end

data/lib/eye/trigger.rb

@@ -1,10 +1,11 @@
 class Eye::Trigger
   autoload :Flapping,   'eye/trigger/flapping'
   autoload :State,      'eye/trigger/state'
+  autoload :StopChilds, 'eye/trigger/stop_childs'
 
   # ex: { :type => :flapping, :times => 2, :within => 30.seconds}
 
-  TYPES = {:flapping => "Flapping", :state => "State"}
+  TYPES = {:flapping => "Flapping", :state => "State", :stop_childs => "StopChilds"}
 
   attr_reader :message, :options, :process
 
@@ -28,6 +29,10 @@ class Eye::Trigger
 
   def self.create(process, options = {})
     get_class(options[:type]).new(process, options)
+
+  rescue Exception, Timeout::Error => ex
+    log_ex(ex)
+    nil
   end
 
   def self.validate!(options = {})
@@ -37,12 +42,13 @@ class Eye::Trigger
   def initialize(process, options = {})
     @options = options
     @process = process
+    @full_name = @process.full_name if @process
 
     debug "add #{options}"
   end
 
   def inspect
-    "<#{self.class} @process='#{@process.full_name}' @options=#{@options}>"
+    "<#{self.class} @process='#{@full_name}' @options=#{@options}>"
   end
 
   def logger_tag
@@ -54,11 +60,25 @@ class Eye::Trigger
   end
 
   def notify(transition)
-    debug "check"
+    debug "check (:#{transition.event}) :#{transition.from} => :#{transition.to}"
     @transition = transition
-    check(transition)
-  rescue => ex
-    warn "failed #{ex.message} #{ex.backtrace}"
+
+    check(transition) if filter_transition(transition)
+
+  rescue Exception, Timeout::Error => ex
+    log_ex(ex)
+  end
+
+  param :to, [Symbol, Array]
+  param :from, [Symbol, Array]
+  param :event, [Symbol, Array]
+
+  def filter_transition(trans)
+    return true unless to || from || event
+
+    compare_state(trans.to_name, to) &&
+      compare_state(trans.from_name, from) &&
+      compare_state(trans.event, event)
   end
 
   def check(transition)
@@ -75,7 +95,6 @@ class Eye::Trigger
 
   def self.register(base)
     name = base.to_s.gsub("Eye::Trigger::", '')
-    name = base.to_s
     type = name.underscore.to_sym
     Eye::Trigger::TYPES[type] = name
     Eye::Trigger.const_set(name, base)
@@ -87,4 +106,18 @@ class Eye::Trigger
       register(base)
     end
   end
+
+private
+
+  def compare_state(state_name, condition)
+    case condition
+    when Symbol
+      state_name == condition
+    when Array
+      condition.include?(state_name)
+    else
+      true
+    end
+  end
+
 end

data/lib/eye/trigger/flapping.rb

@@ -14,9 +14,7 @@ class Eye::Trigger::Flapping < Eye::Trigger
   end
 
   def check(transition)
-    unless good?
-      on_flapping
-    end
+    on_flapping if transition.event == :crashed && !good?
   end
 
 private

data/lib/eye/trigger/state.rb

@@ -2,27 +2,10 @@ class Eye::Trigger::State < Eye::Trigger
 
   # triggers :state, :to => :up, :from => :starting, :do => ->{ ... }
 
-  param :to, [Symbol, Array]
-  param :from, [Symbol, Array]
-  param :event, [Symbol, Array]
   param :do, [Proc]
 
   def check(trans)
-    if compare(trans.to_name, to) || compare(trans.from_name, from) || compare(trans.event, event)
-      debug "trans ok #{trans}, executing proc!"
-      run_in_process_context(@options[:do]) if @options[:do]
-    end
-  end
-
-private
-
-  def compare(state_name, condition)
-    case condition
-    when Symbol
-      state_name == condition
-    when Array
-      condition.include?(state_name)
-    end
+    instance_exec(&@options[:do]) if @options[:do]
   end
 
 end

data/lib/eye/trigger/stop_childs.rb

@@ -0,0 +1,10 @@
+class Eye::Trigger::StopChilds < Eye::Trigger
+
+  param :timeout, [Fixnum, Float], nil, 60
+
+  def check(trans)
+    debug "stop childs"
+    process.childs.pmap { |pid, c| c.stop }
+  end
+
+end

data/lib/eye/utils/alive_array.rb

@@ -3,7 +3,7 @@ class Eye::Utils::AliveArray
   include Enumerable
 
   def_delegators :@arr, :[], :<<, :clear, :delete, :size, :empty?, :push,
-                        :flatten, :present?, :uniq!
+                        :flatten, :present?, :uniq!, :select!
 
   def initialize(arr = [])
     @arr = arr

data/lib/eye/utils/celluloid_chain.rb

@@ -7,6 +7,7 @@ class Eye::Utils::CelluloidChain
     @target = target
     @calls = []
     @running = false
+    @target_class = @target.class
   end
 
   def add(method_name, *args, &block)
@@ -46,7 +47,7 @@ class Eye::Utils::CelluloidChain
 
   # need, because of https://github.com/celluloid/celluloid/issues/22
   def inspect
-    "Celluloid::Chain(#{@target.class}: #{@calls.inspect})"
+    "Celluloid::Chain(#{@target_class}: #{@calls.size})"
   end
 
   attr_reader :running

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eye
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: 0.4.1
 platform: ruby
 authors:
 - Konstantin Makarchev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-11 00:00:00.000000000 Z
+date: 2013-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -248,8 +248,8 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Process monitoring tool. An alternative to God and Bluepill. With Bluepill
-  like config syntax. Requires MRI Ruby >= 1.9.2. Uses Celluloid and Celluloid::IO.
+description: Process monitoring tool. Inspired from Bluepill and God. Requires Ruby(MRI)
+  >= 1.9.3-p194. Uses Celluloid and Celluloid::IO.
 email: kostya27@gmail.com
 executables:
 - eye
@@ -288,6 +288,7 @@ files:
 - lib/eye/checker/file_size.rb
 - lib/eye/checker/http.rb
 - lib/eye/checker/memory.rb
+- lib/eye/checker/nop.rb
 - lib/eye/checker/socket.rb
 - lib/eye/child_process.rb
 - lib/eye/client.rb
@@ -343,6 +344,7 @@ files:
 - lib/eye/trigger.rb
 - lib/eye/trigger/flapping.rb
 - lib/eye/trigger/state.rb
+- lib/eye/trigger/stop_childs.rb
 - lib/eye/utils.rb
 - lib/eye/utils/alive_array.rb
 - lib/eye/utils/celluloid_chain.rb
@@ -372,6 +374,6 @@ rubyforge_project:
 rubygems_version: 2.0.2
 signing_key: 
 specification_version: 4
-summary: Process monitoring tool. An alternative to God and Bluepill. With Bluepill
-  like config syntax. Requires MRI Ruby >= 1.9.2. Uses Celluloid and Celluloid::IO.
+summary: Process monitoring tool. Inspired from Bluepill and God. Requires Ruby(MRI)
+  >= 1.9.3-p194. Uses Celluloid and Celluloid::IO.
 test_files: []