eye 0.1.11

data/bin/loader_eye

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+require 'eye/loader'
+require 'optparse'
+require 'eye'
+
+options = {:debug => false}
+
+OptionParser.new do |opts|
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    exit
+  end
+
+  opts.on( '-c', '--config CONFIG', 'load with config' ) do |config_path|
+    options[:config] = config_path
+  end
+
+  opts.on( '-s', '--socket SOCKET', 'start listen on socket' ) do |socket_path|
+    options[:socket_path] = socket_path
+  end
+
+  opts.on( '-l', '--logger LOGGER', 'custom logger' ) do |logger|
+    options[:logger] = logger
+  end
+
+  opts.on( '-d', '--debug', 'debug info to logger' ) do
+    options[:debug] = true
+  end
+
+end.parse!
+
+Eye::Settings.ensure_eye_dir
+
+socket_path = options[:socket_path] || Eye::Settings.socket_path
+server = Eye::Server.new(socket_path)
+
+Eye::Logger.log_level = options[:debug] ? Logger::DEBUG : Logger::INFO
+Eye::Logger.link_logger(options[:logger]) if options[:logger]
+
+config = options[:config]
+config = File.expand_path(config) if config && !config.empty?
+if config
+  res = server.command('load', config)
+  exit if res[:error]
+end
+
+Eye::Control.set_proc_line
+
+server.run!
+
+Kernel.trap("INT") do # for foregraund quit
+  exit
+end
+
+sleep

data/examples/processes/em.rb

@@ -0,0 +1,56 @@
+require 'bundler/setup'
+require 'eventmachine'
+
+def answer(data)
+  case data
+    when 'ping' then "pong\n"
+    when 'bad' then "what\n"
+    when 'timeout' then sleep 5; "ok\n"
+    when 'exception' then raise 'haha'
+    when 'quit' then EM.stop
+    when 'big' then 'a' * 10_000_000
+  end
+end
+
+class Echo < EM::Connection
+  def post_init
+    puts "-- someone connected to the echo server!"
+  end
+
+  def receive_data data
+    puts "receive #{data.inspect} "
+    send_data(answer(data))
+  end
+
+  def unbind
+     puts "-- someone disconnected from the echo server!"
+  end  
+end
+
+class EchoObj < EM::Connection
+  include EM::P::ObjectProtocol
+
+  def post_init
+    puts "-- someone connected to the echo server!"
+  end
+
+  def receive_object obj # {:command => 'ping'}
+    puts "receive #{obj.inspect}"
+    send_object(answer(obj[:command]).chop)
+  end
+
+  def unbind
+    puts "-- someone disconnected from the echo server!"
+  end  
+end
+
+trap "TERM" do
+  EM.stop
+end
+
+EM.run do
+  EM.start_server '127.0.0.1', 33221, Echo
+  EM.start_server '127.0.0.1', 33222, EchoObj
+  EM.start_server "/tmp/em_test_sock", nil, Echo
+  puts 'started'
+end

data/examples/processes/forking.rb

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+require 'forking'
+
+root = File.expand_path(File.dirname(__FILE__))
+
+f = Forking.new(:name => 'forking', :working_dir => root,
+    :log_file => "#{root}/forking.log", 
+    :pid_file => "#{root}/forking.pid", :sync_log => true)
+
+3.times do |i|
+  f.spawn(:log_file => "#{root}/child#{i}.log", :sync_log => true) do
+    $0 = "forking child"
+    loop do
+      p "#{Time.now} - #{Time.now.to_f} - #{i} - tick" 
+      sleep 0.1
+    end
+  end
+end
+
+f.run!

data/examples/processes/sample.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+# This hash will hold all of the options
+# parsed from the command-line by
+# OptionParser.
+options = {}
+
+optparse = OptionParser.new do|opts|
+  # This displays the help screen, all programs are
+  # assumed to have this option.
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    exit
+  end
+
+  opts.on( '-p', '--pid FILE', 'pid_file' ) do |a| 
+    options[:pid_file] = a
+  end
+
+  opts.on( '-l', '--log FILE', 'log_file' ) do |a| 
+    options[:log_file] = a
+  end
+
+  opts.on( '-L', '--lock FILE', 'lock_file' ) do |a| 
+    options[:lock_file] = a
+  end
+
+  opts.on( '-d', '--daemonize', 'Daemonize' ) do 
+    options[:daemonize] = true
+  end
+
+  opts.on( '-s', '--daemonize_delay DELAY', 'Daemonized time' ) do |d|
+    options[:daemonize_delay] = d
+  end
+
+  opts.on( '-r', '--raise', 'Raised execution' ) do 
+    options[:raise] = true
+  end
+
+  opts.on( '-w', '--watch_file FILE', 'Exit on touched file' ) do |w|
+    options[:watch_file] = w
+  end
+
+  opts.on( '-W', '--watch_file_delay DELAY', 'Exit on touched file, after delay' ) do |w|
+    options[:watch_file_delay] = w
+  end
+
+end
+
+optparse.parse!
+
+module Sample
+  def puts(mes = "")
+    tm = Time.now
+    STDOUT.puts "#{tm.to_s} (#{tm.to_f}) - #{mes}"
+    STDOUT.flush
+  end
+
+  def daemonize(pid_file, log_file, daemonize_delay = 0)
+    puts "daemonize start #{pid_file}, #{log_file}, #{daemonize_delay}"
+
+    if daemonize_delay && daemonize_delay.to_f > 0
+      puts "daemonize delay start #{daemonize_delay}"
+      sleep daemonize_delay.to_f
+      puts "daemonize delay end"
+    end
+
+    daemon
+    STDOUT.reopen(log_file, "a")
+    STDERR.reopen(log_file, "a")
+    File.open(pid_file, 'w'){|f| f.write $$.to_s}
+
+    puts "daemonized"
+  end
+
+  def daemon
+    exit if fork                     # Parent exits, child continues.
+    Process.setsid                   # Become session leader.
+    exit if fork                     # Zap session leader. See [1].
+
+    STDIN.reopen "/dev/null"         # Free file descriptors and
+    STDOUT.reopen "/dev/null", "a"   # point them somewhere sensible.
+    STDERR.reopen '/dev/null', 'a'
+    return 0
+  end
+end
+
+extend Sample
+
+if options[:daemonize]
+  daemonize(options[:pid_file], options[:log_file], options[:daemonize_delay])
+end
+
+puts "Started #{ARGV.inspect}, #{options.inspect}, #{ENV["ENV1"]}"
+
+if options[:lock_file]
+  if File.exists?(options[:lock_file])
+    puts "Lock file exists, exiting"
+    exit 1
+  else
+    File.open(options[:lock_file], 'w'){|f| f.write $$ }
+  end
+end
+
+if options[:raise]
+  puts "Raised"
+  File.unlink(options[:lock_file]) if options[:lock_file]
+  exit 1
+end
+
+trap("USR1") do
+  puts "USR1 signal!"
+end
+
+trap("USR2") do
+  puts "USR2 start memory leak"
+  $ar = []
+  300_000.times{|i| $ar << "memory leak #{i}" * 10}
+end
+
+loop do
+  sleep 0.1
+  puts "tick"
+
+  if options[:watch_file]
+    if File.exists?(options[:watch_file])
+      puts "watch file finded"
+      File.unlink(options[:watch_file])
+
+      if options[:watch_file_delay]
+        puts "watch_file delay start"
+        sleep options[:watch_file_delay].to_f
+        puts "watch_file delay end"
+      end
+
+      break
+    end
+  end
+end
+
+puts "exit"
+File.unlink(options[:lock_file]) if options[:lock_file]
+exit 0

data/examples/rbenv.eye

@@ -0,0 +1,11 @@
+Eye.application "rbenv_example" do
+  env 'RBENV_ROOT' => '/usr/local/rbenv', 'PATH' => "/usr/local/rbenv/shims:/usr/local/rbenv/bin:#{ENV['PATH']}"
+  working_dir "/projects/some_project"
+  
+  process "some_process" do
+    pid_file "some.pid"
+    start_command "ruby some.rb"
+    daemonize true
+    stdall "some.log"
+  end
+end

data/examples/test.eye

@@ -0,0 +1,65 @@
+Eye.load("./eye/*.rb") # load submodules
+Eye.config do
+  logger "/tmp/eye.log" # eye logger
+  logger_level Logger::DEBUG
+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
+  
+  process :event_machine do
+    pid_file 'em.pid'
+    start_command 'ruby em.rb'
+    stdall 'em.log'
+    daemonize true
+    
+    checks :socket, :addr => "tcp://127.0.0.1:33221", :send_data => "ping", :expect_data => /pong/,
+                    :every => 10.seconds, :times => 2, :timeout => 1.second
+  end
+
+end

data/examples/unicorn.eye

@@ -0,0 +1,29 @@
+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']}"
+  working_dir "/projects/rails_unicorn"
+  
+  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]
+
+    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]
+    end
+  end
+
+end

data/eye.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/eye', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = "Konstantin Makarchev"
+  gem.email         = "kostya27@gmail.com"
+
+  gem.description   = %q{Process monitoring tool. With Bluepill like config syntax. Requires MRI Ruby >= 1.9.2. Uses Celluloid and Celluloid::IO.}
+  gem.summary       = %q{Process monitoring tool. With Bluepill like config syntax. Requires MRI Ruby >= 1.9.2. Uses Celluloid and Celluloid::IO.}
+  gem.homepage      = "http://github.com/kostya/eye"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "eye"
+  gem.require_paths = ["lib"]
+  gem.version       = Eye::VERSION
+  gem.license       = "MIT"
+
+  gem.required_ruby_version     = '>= 1.9.2' # because of celluloid
+  gem.required_rubygems_version = '>= 1.3.6'  
+  
+  gem.add_dependency 'celluloid',     '~> 0.12.0'
+  gem.add_dependency 'celluloid-io',  '~> 0.12.0'
+  gem.add_dependency 'state_machine'
+  gem.add_dependency 'activesupport', '~> 3.2.0'
+  gem.add_dependency 'thor'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'rr'
+  gem.add_development_dependency 'ruby-graphviz'
+  gem.add_development_dependency 'forking'
+  gem.add_development_dependency 'fakeweb'
+  gem.add_development_dependency 'eventmachine'
+end

data/lib/eye.rb

@@ -0,0 +1,25 @@
+module Eye  
+  VERSION   = "0.1.11"
+  ABOUT     = "Eye v#{VERSION} (c) 2012-2013 @kostya"
+
+  autoload :Process,        'eye/process'
+  autoload :ChildProcess,   'eye/child_process'
+  autoload :Server,         'eye/server'
+  autoload :Logger,         'eye/logger'
+  autoload :System,         'eye/system'
+  autoload :SystemResources,'eye/system_resources'  
+  autoload :Checker,        'eye/checker'
+  autoload :Trigger,        'eye/trigger'
+  autoload :Group,          'eye/group'
+  autoload :Dsl,            'eye/dsl'  
+  autoload :Application,    'eye/application'  
+  autoload :Settings,       'eye/settings'
+  autoload :Client,         'eye/client'
+  autoload :Utils,          'eye/utils'
+  
+  autoload :Controller,     'eye/controller'
+  autoload :Control,        'eye/control'
+end
+
+ROOT_BINDING  = binding
+ENV_LANG      = ENV['LANG'] # save original LANG, because ruby somehow rewrite it