eye 0.1.11

data/.gitignore

@@ -0,0 +1,31 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.pid
+*.log
+*.swp
+*~
+TODO
+.todo
+*.png
+*.lock
+experiments
+.git2
+*.stop
+*sublime*
+examples/work*.eye
+script

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--profile

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# Specify your gem's dependencies in eye.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012-2013 'Konstantin Makarchev'
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+Eye
+===
+
+Process monitoring tool. With Bluepill like config syntax. Requires MRI Ruby >= 1.9.2. Uses Celluloid and Celluloid::IO.
+
+
+Recommended installation on the server (system wide):
+
+    $ sudo /usr/local/ruby/1.9.3/bin/gem install eye
+    $ sudo ln -sf /usr/local/ruby/1.9.3/bin/eye /usr/local/bin/eye
+
+
+Config example, shows most of the options (examples/test.eye):
+
+```ruby
+Eye.load("./eye/*.rb") # load submodules
+Eye.config do
+  logger "/tmp/eye.log" # eye logger
+end
+
+Eye.app "test" do
+  working_dir File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
+  stdall "trash.log" # stdout + stderr
+  env "APP_ENV" => "production"
+  triggers :flapping, :times => 10, :within => 1.minute
+
+  group "samples" do
+    env "A" => "1" # env merging
+    chain :grace => 5.seconds, :action => :restart # restarting with 5s interval, one by one.
+
+    # eye daemonized process
+    process("sample1") do
+      pid_file "1.pid" # expanded with working_dir
+      start_command "ruby ./sample.rb"
+      daemonize true
+      stdall "sample1.log"
+
+      checks :cpu, :below => 30, :times => [3, 5]
+    end
+
+    # self daemonized process
+    process("sample2") do
+      pid_file "2.pid"
+      start_command "ruby ./sample.rb -d --pid 2.pid --log sample2.log"
+      stop_command "kill -9 {{PID}}"
+
+      checks :memory, :below => 300.megabytes, :times => 3
+    end
+  end
+
+  # daemon with 3 childs
+  process("forking") do
+    pid_file "forking.pid"
+    start_command "ruby ./forking.rb start"
+    stop_command "ruby forking.rb stop"
+    stdall "forking.log"
+
+    start_timeout 5.seconds
+    stop_grace 5.seconds
+  
+    monitor_children do
+      childs_update_period 5.seconds
+
+      restart_command "kill -2 {{PID}}"
+      checks :memory, :below => 300.megabytes, :times => 3
+    end
+  end
+
+end
+```
+
+### Start monitoring and load config:
+
+    $ eye l(oad) examples/test.eye
+
+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).
+
+
+Process statuses:
+  
+    $ eye i(nfo)
+
+```
+test                               
+  samples                          
+    sample1 ....................... up  (21:38, 0%, 15Mb, <4813>)
+    sample2 ....................... up  (21:36, 0%, 14Mb, <4530>)
+  forking ......................... up  (21:34, 0%, 19Mb, <4272>)
+    =child= ....................... up  (21:34, 0%, 22Mb, <4275>)
+    =child= ....................... up  (21:34, 0%, 21Mb, <4278>)
+    =child= ....................... up  (21:34, 0%, 21Mb, <4281>)
+```
+
+### Commands:
+    
+    start, stop, restart, delete, monitor, unmonitor
+
+Command params (with restart for example):
+
+    $ eye r(estart) all
+    $ eye r test
+    $ eye r samples
+    $ eye r sample1
+    $ eye r sample*
+    $ eye r test:samples
+    $ eye r test:samples:sample1
+    $ eye r test:samples:sample*
+    $ eye r test:*sample*
+
+Check config syntax:
+
+    $ eye c(heck) examples/test.eye
+
+Log tracing:
+
+    $ eye trace 
+    $ eye tr test
+    $ eye tr sample
+
+Quit monitoring:
+
+    $ eye q(uit)
+
+Config explain (for debug):
+
+    $ eye explain examples/test.eye

data/Rakefile

@@ -0,0 +1,18 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+task :default => :spec
+RSpec::Core::RakeTask.new(:spec)
+
+task :env do
+  require 'bundler/setup'
+  require 'eye'
+  Eye::Control
+  Eye::Process # preload
+end
+
+desc "graph"
+task :graph => :env do
+  StateMachine::Machine.draw("Eye::Process")
+end

data/bin/eye

@@ -0,0 +1,282 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'eye'
+
+gem 'thor'
+require 'thor'
+
+class Cli < Thor
+
+  desc "info [MASK]", "show process statuses"
+  def info(mask = nil)
+    res = cmd(:info, mask)
+    puts res if res && !res.empty?
+    puts
+  end
+
+  desc "status ", "show process statuses"
+  def status
+    say ":status is deprecated, use :info instead", :yellow
+    info
+  end
+
+  desc "xinfo", "extended eye info, debug data"
+  method_option :config, :type => :boolean, :aliases => "-c"
+  def xinfo    
+    res = cmd(:xinfo, options[:config])
+    puts res if res && !res.empty?
+    puts
+  end
+
+  desc "oinfo", "onelined info"
+  def oinfo
+    res = cmd(:oinfo)
+    puts res if res && !res.empty?
+    puts
+  end
+
+  desc "load [CONF]", "load config (and start server if needed) (-f for foregraund start)"
+  method_option :foregraund, :type => :boolean, :aliases => "-f"
+  method_option :logger, :type => :string, :aliases => "-l"
+  def load(conf = "")
+    conf = File.expand_path(conf) if !conf.empty?
+
+    if options[:foregraund]
+      # in foregraund we stop another server, and run just 1 current config version
+      server_start_foregraund(conf)
+
+    elsif server_started?
+      say_load_result cmd(:load, conf)
+
+    else
+      server_start(conf)
+
+    end
+  end
+
+  desc "quit", "stop eye monitoring"
+  def quit
+    res = _cmd(:quit)
+
+    # if eye server got crazy, stop by force
+    ensure_stop_previous_server if res != :corrupred_marshal
+
+    say "stopped...", :yellow
+  end
+  
+  [:start, :stop, :restart, :unmonitor, :monitor, :delete, :match].each do |_cmd|
+    desc "#{_cmd} MASK[,...]", "#{_cmd} app,group or process"
+    define_method(_cmd) do |*targets|
+      send_command(_cmd, *targets)
+    end
+  end
+
+  desc "signal SIG, MASK[,...]", "send signal to matched app,group or process (ex: `eye sig USR2 some_app`)"
+  def signal(sig, *targets)
+    send_command(:signal, sig, *targets)
+  end
+
+  desc "trace [TARGET]", "tracing log for app,group or process"
+  def trace(target = "")
+    log_trace(target)
+  end
+
+  desc "version", "show current version"
+  def version
+    say Eye::ABOUT
+  end
+
+  desc "check CONF", "check syntax of the config file"
+  method_option :host, :type => :string, :aliases => "-h"
+  method_option :verbose, :type => :boolean, :aliases => "-v"
+  def check(conf)
+    conf = File.expand_path(conf) if conf && !conf.empty?
+
+    Eye::System.host = options[:host] if options[:host]
+    Eye::Dsl.verbose = options[:verbose]
+    
+    if RUBY_VERSION < '1.9'
+      say_load_result cmd(:check, conf), :syntax => true
+    else
+      say_load_result Eye::Control.check(conf), :syntax => true
+    end
+  end
+
+  desc "explain CONF", "explain config tree (for debug)"
+  method_option :host, :type => :string, :aliases => "-h"
+  method_option :verbose, :type => :boolean, :aliases => "-v"
+  def explain(conf)
+    conf = File.expand_path(conf) if conf && !conf.empty?
+
+    Eye::System.host = options[:host] if options[:host]
+    Eye::Dsl.verbose = options[:verbose]
+
+    if RUBY_VERSION < '1.9'
+      say_load_result cmd(:explain, conf), :print_config => true, :syntax => true
+    else
+      say_load_result Eye::Control.explain(conf), :print_config => true, :syntax => true
+    end
+  end
+
+private
+
+  def client
+    @client ||= Eye::Client.new(Eye::Settings.socket_path)
+  end
+
+  def _cmd(cmd, *args)
+    client.command(cmd, *args)
+  rescue Errno::ECONNREFUSED, Errno::ENOENT
+    :not_started
+  end
+  
+  def cmd(cmd, *args)
+    res = _cmd(cmd, *args)
+
+    if res == :not_started
+      say "eye monitoring not found, did you start it?", :red
+      exit 1
+    elsif res == :timeouted
+      say "eye does not answer, timeouted...", :red
+      exit 1
+    end
+    
+    res
+  end
+  
+  def server_started?
+    _cmd(:ping) == :pong
+  end
+  
+  def say_load_result(res = {}, opts = {})
+    if res[:error]
+      say "config error: ", :red
+      say res[:message]
+
+      res[:backtrace].to_a.each{|line| say line}
+
+      exit 1
+    else 
+      if opts[:started]
+        say "started and loaded!", :yellow if !res[:empty]
+      elsif opts[:syntax]
+        say "config ok!", :yellow if !res[:empty]
+      else
+        say "config loaded!", :yellow if !res[:empty]        
+      end
+
+      if opts[:print_config]
+        require 'yaml'
+        puts YAML.dump(res[:config])
+      end
+    end
+  end
+
+  def send_command(_cmd, *args)
+    res = cmd(_cmd, *args)
+    if res == :unknown_command
+      say "unknown command :#{_cmd}", :red
+    elsif res == :corrupred_marshal
+      say "something crazy wrong, check eye logs!", :red
+    elsif res == []
+      say "command :#{_cmd}, targets not found!", :red
+    else
+      say "command :#{_cmd} sended to [#{res * ", "}]"
+    end        
+  end
+
+  def log_trace(tag = '')
+    log_file = cmd(:logger_dev)
+    if log_file && File.exists?(log_file)
+      Process.exec "tail -n 100 -f #{log_file} | grep '#{tag}'"
+    else
+      say "log file not found #{log_file.inspect}", :red
+    end
+  end
+  
+  def loader_path
+    Gem.bin_path('eye', 'loader_eye')
+  rescue Gem::GemNotFoundException, Gem::Exception
+    filename = File.expand_path(File.join(File.dirname(__FILE__), %w[loader_eye]))
+    File.exists?(filename) ? filename : nil
+  end  
+  
+  def ruby_path
+    require 'rbconfig'
+    RbConfig::CONFIG['bindir'] + "/ruby"
+  end
+
+  def ensure_loader_path
+    unless loader_path
+      say "start monitoring needs to run under ruby with installed gem 'eye'", :red
+      exit 1
+    end
+  end
+
+  def server_start_foregraund(conf = nil)
+    ensure_loader_path
+    Eye::Settings.ensure_eye_dir
+
+    if server_started?
+      _cmd(:quit) && sleep(1) # stop previous server
+    end
+
+    args = []
+    args += ['-c', conf] if conf
+    args += ['-l', 'stdout']
+
+    Process.exec(ruby_path, loader_path, *args)
+  end
+
+  def server_start(conf = nil)
+    ensure_loader_path
+    Eye::Settings.ensure_eye_dir
+
+    ensure_stop_previous_server
+    
+    args = []
+    args += ['-l', options[:logger]] if options[:logger]
+
+    pid = Process.spawn(ruby_path, loader_path, *args, :out => '/dev/null', :err => '/dev/null', :in => '/dev/null',
+                        :chdir => '/', :pgroup => true)
+    Process.detach(pid)
+    File.open(Eye::Settings.pid_path, 'w'){|f| f.write(pid) }
+
+    unless wait_server
+      say "server not runned in 15 seconds, something crazy wrong", :red
+      exit 1
+    end
+
+    if conf && !conf.empty?
+      say_load_result cmd(:load, conf), :started => true
+    else
+      say "started!", :yellow
+    end
+  end
+
+  def ensure_stop_previous_server
+    Eye::Settings.ensure_eye_dir
+    pid = File.read(Eye::Settings.pid_path).to_i rescue nil
+    if pid
+      Process.kill(9, pid) rescue nil
+    end
+    File.delete(Eye::Settings.pid_path) rescue nil
+    true
+  end
+
+  def wait_server
+    Timeout.timeout(15) do
+      while !server_started?
+        sleep 0.3
+      end
+    end
+
+    true
+  rescue Timeout::Error
+    false
+  end
+
+end
+
+Cli.start