reel-eye 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 464e9e9a66aef932d82c8452238c083bfc3561da
+  data.tar.gz: 795aaf16fec1578814570cdeff914cf5792144f6
+SHA512:
+  metadata.gz: f68bc9205b02c7b3a1643c4f97a5a6f7e151391b93563019663d84b9bf335a8c5a180445ea4b1f97d888fc64d4ba3c3fa6fa1cefdaa404a9d8fe472a96f42f62
+  data.tar.gz: 9dcf75372e1a0a93f68a1f7ff04542b1ff391a9522597f7203322157b5860c8bf0243fb271b41c19567077dd70c657bc154061a2a35267149b68469acea7e011

data/.gitignore

@@ -0,0 +1,32 @@
+*.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
+[0-9].rb

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - "1.9.3"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# 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,170 @@
+Eye [![Build Status](https://secure.travis-ci.org/kostya/eye.png?branch=master)](http://travis-ci.org/kostya/eye)
+===
+
+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.
+
+Little demo, shows general commands and how chain works:
+
+[![Eye](https://raw.github.com/kostya/stuff/master/eye/eye.png)](https://raw.github.com/kostya/stuff/master/eye/eye.gif)
+
+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 some typical processes and most of the options (see in exampes/ folder):
+
+examples/test.eye
+```ruby
+# load submodules, here just for example
+Eye.load("./eye/*.rb") 
+
+# Eye self-configuration section
+Eye.config do
+  logger "/tmp/eye.log"
+end
+
+# Adding application
+Eye.application "test" do
+  # All options inherits down to the config leafs.
+  # except `env`, which merging down
+
+  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
+
+  group "samples" do
+    chain :grace => 5.seconds # chained start-restart with 5s interval, one by one.
+
+    # eye daemonized process
+    process :sample1 do
+      pid_file "1.pid" # pid_path will be expanded with the 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
+      restart_command "kill -2 {PID}" # for this child process
+      checks :memory, :below => 300.megabytes, :times => 3
+    end
+  end
+  
+  # eventmachine process, daemonized with eye
+  process :event_machine do |p|
+    pid_file 'em.pid'
+    start_command 'ruby em.rb'
+    stdout 'em.log'
+    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/
+  end
+
+  # thin process, self daemonized
+  process :thin do
+    pid_file "thin.pid"
+    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
+  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:52, 0%, 13Mb, <4107>)
+    sample2 ....................... up  (21:52, 0%, 12Mb, <4142>)
+  event_machine ................... up  (21:52, 3%, 26Mb, <4112>)
+  forking ......................... up  (21:52, 0%, 41Mb, <4203>)
+    child-4206 .................... up  (21:52, 0%, 41Mb, <4206>)
+    child-4211 .................... up  (21:52, 0%, 41Mb, <4211>)
+    child-4214 .................... up  (21:52, 0%, 41Mb, <4214>)
+  thin ............................ up  (21:53, 2%, 54Mb, <4228>)
+```
+
+### 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
+
+
+### Config api:
+
+  Waiting for pull requests ..., until that you can read `examples` and `spec/dsl` folders.

data/Rakefile

@@ -0,0 +1,20 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+task :default => :spec
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+end
+
+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,322 @@
+#!/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"
+  method_option :show_processes, :type => :boolean, :aliases => "-p"
+  def xinfo    
+    res = cmd(:xinfo, options[:config], options[:show_processes])
+    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(*configs)
+    configs.map!{ |c| File.expand_path(c) } if !configs.empty?
+
+    if options[:foregraund]
+      # in foregraund we stop another server, and run just 1 current config version
+      if configs.size != 1
+        say "foregraund expected only one config", :red
+        exit 1
+      end
+
+      server_start_foregraund(configs.first)
+
+    elsif server_started?
+      say_load_result cmd(:load, *configs)
+
+    else
+      server_start(configs)
+
+    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 "break TARGET[,...]", "break group chain executing"
+  def break(*targets)
+    send_command(:break_chain, *targets)
+  end
+
+  desc "history TARGET[,...]", "show process states history"
+  def history(*targets)
+    res = cmd(:history, *targets)
+    puts res if res && !res.empty?
+    puts
+  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
+
+  desc "watch [MASK]", "interactive process info"
+  def watch(*args)
+    pid = Process.spawn("watch -n 1 --color #{$0} i #{args * ' '}")
+    Process.waitpid(pid)
+  rescue Interrupt
+  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 = {})
+    say(res) unless res.is_a?(Hash)
+
+    if res.has_key?(:error) # TODO: remove that case, outdated
+      show_load_message(res, opts)
+      exit 1 if res[:error]
+    else
+      say_filename = (res.size > 1)
+      say "eye started!", :green if opts[:started]
+      res.each do |filename, _res|
+        say "#{filename}: ", nil, true if say_filename
+        show_load_message(_res, opts)
+      end
+    end
+  end
+
+  def show_load_message(res, opts = {})
+    if res[:error]
+      say res[:message], :red
+      res[:backtrace].to_a.each{|line| say line, :red }
+    else
+      all_error = false
+      if opts[:syntax]
+        say "config ok!", :green if !res[:empty]
+      else
+        say "config loaded!", :green if !res[:empty]
+      end
+
+      if opts[:print_config]
+        require 'pp'
+        PP.pp 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
+    if RUBY_VERSION < '1.9'
+      begin
+        return Gem.bin_path('eye', 'loader_eye')
+      rescue Gem::GemNotFoundException, Gem::Exception
+      end
+    end
+
+    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(configs)
+    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
+
+    configs.unshift(Eye::Settings.eyeconfig) if File.exists?(Eye::Settings.eyeconfig)
+
+    if !configs.empty?
+      say_load_result cmd(:load, *configs), :started => true
+    else
+      say "started!", :green
+    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 = 15)
+    Timeout.timeout(timeout) do
+      sleep 0.3 while !server_started?
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+
+end
+
+Cli.start