eye 0.8.celluloid15 → 0.8.pre

data/examples/processes/forking.rb

@@ -4,13 +4,13 @@ require 'forking'
 root = File.expand_path(File.dirname(__FILE__))
 cnt = (ENV['FORKING_COUNT'] || 3).to_i
 
-f = Forking.new(name: 'forking', working_dir: root,
-                log_file: "#{root}/forking.log",
-                pid_file: "#{root}/forking.pid", sync_log: true)
+f = Forking.new(:name => 'forking', :working_dir => root,
+    :log_file => "#{root}/forking.log",
+    :pid_file => "#{root}/forking.pid", :sync_log => true)
 
 cnt.times do |i|
-  f.spawn(log_file: "#{root}/child#{i}.log", sync_log: true) do
-    $0 = 'forking child'
+  f.spawn(:log_file => "#{root}/child#{i}.log", :sync_log => true) do
+    $0 = "forking child"
     t = 0
     loop do
       p "#{Time.now} - #{Time.now.to_f} - #{i} - tick"

data/examples/processes/sample.rb

@@ -9,49 +9,49 @@ 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
+  opts.on( '-h', '--help', 'Display this screen' ) do
     puts opts
     exit
   end
 
-  opts.on('-p', '--pid FILE', 'pid_file') do |a|
+  opts.on( '-p', '--pid FILE', 'pid_file' ) do |a|
     options[:pid_file] = a
   end
 
-  opts.on('-l', '--log FILE', 'log_file') do |a|
+  opts.on( '-l', '--log FILE', 'log_file' ) do |a|
     options[:log_file] = a
   end
 
-  opts.on('-L', '--lock FILE', 'lock_file') do |a|
+  opts.on( '-L', '--lock FILE', 'lock_file' ) do |a|
     options[:lock_file] = a
   end
 
-  opts.on('-d', '--daemonize', 'Daemonize') do
+  opts.on( '-d', '--daemonize', 'Daemonize' ) do
     options[:daemonize] = true
   end
 
-  opts.on('-s', '--daemonize_delay DELAY', 'Daemonized time') do |d|
+  opts.on( '-s', '--daemonize_delay DELAY', 'Daemonized time' ) do |d|
     options[:daemonize_delay] = d
   end
 
-  opts.on('-r', '--raise', 'Raised execution') do
+  opts.on( '-r', '--raise', 'Raised execution' ) do
     options[:raise] = true
   end
 
-  opts.on('-w', '--watch_file FILE', 'Exit on touched file') do |w|
+  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|
+  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 = '')
+  def puts(mes = "")
     tm = Time.now
     STDOUT.puts "#{tm} (#{tm.to_f}) - #{mes}"
     STDOUT.flush
@@ -63,15 +63,15 @@ module Sample
     if daemonize_delay && daemonize_delay.to_f > 0
       puts "daemonize delay start #{daemonize_delay}"
       sleep daemonize_delay.to_f
-      puts 'daemonize delay end'
+      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 }
+    STDOUT.reopen(log_file, "a")
+    STDERR.reopen(log_file, "a")
+    File.open(pid_file, 'w'){|f| f.write $$.to_s}
 
-    puts 'daemonized'
+    puts "daemonized"
   end
 
   def daemon
@@ -79,12 +79,11 @@ module Sample
     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.
+    STDIN.reopen "/dev/null"         # Free file descriptors and
+    STDOUT.reopen "/dev/null", "a"   # point them somewhere sensible.
     STDERR.reopen '/dev/null', 'a'
-    0
+    return 0
   end
-
 end
 
 extend Sample
@@ -97,50 +96,49 @@ puts "Started #{ARGV.inspect}, #{options.inspect}, #{ENV['ENV1']}"
 
 if options[:lock_file]
   if File.exist?(options[:lock_file])
-    puts 'Lock file exists, exiting'
+    puts "Lock file exists, exiting"
     exit 1
   else
-    File.open(options[:lock_file], 'w') { |f| f.write $$ }
+    File.open(options[:lock_file], 'w'){|f| f.write $$ }
   end
 end
 
 if options[:raise]
-  puts 'Raised'
+  puts "Raised"
   File.unlink(options[:lock_file]) if options[:lock_file]
   exit 1
 end
 
-trap('USR1') do
-  puts 'USR1 signal!'
+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 }
+trap("USR2") do
+  puts "USR2 start memory leak"
+  $ar = []
+  300_000.times{|i| $ar << "memory leak #{i}" * 10}
 end
 
-def check_watch_file(options)
-  return unless options[:watch_file] && File.exist?(options[:watch_file])
-
-  puts 'watch file finded'
-  File.unlink(options[:watch_file])
+loop do
+  sleep 0.1
+  puts "tick"
 
-  if options[:watch_file_delay]
-    puts 'watch_file delay start'
-    sleep options[:watch_file_delay].to_f
-    puts 'watch_file delay end'
-  end
+  if options[:watch_file]
+    if File.exist?(options[:watch_file])
+      puts "watch file finded"
+      File.unlink(options[:watch_file])
 
-  true
-end
+      if options[:watch_file_delay]
+        puts "watch_file delay start"
+        sleep options[:watch_file_delay].to_f
+        puts "watch_file delay end"
+      end
 
-loop do
-  sleep 0.1
-  puts 'tick'
-  break if check_watch_file(options)
+      break
+    end
+  end
 end
 
-puts 'exit'
+puts "exit"
 File.unlink(options[:lock_file]) if options[:lock_file]
 exit 0

data/examples/puma.eye

@@ -9,22 +9,21 @@ end
 Eye.application :puma do
   env 'RAILS_ENV' => RAILS_ENV
   working_dir ROOT
-  trigger :flapping, times: 10, within: 1.minute
+  trigger :flapping, :times => 10, :within => 1.minute
 
   process :puma do
     daemonize true
-    pid_file 'puma.pid'
-    stdall 'puma.log'
+    pid_file "puma.pid"
+    stdall "puma.log"
 
     start_command "#{BUNDLE} exec puma --port 33280 --environment #{RAILS_ENV} thin.ru"
     stop_signals [:TERM, 5.seconds, :KILL]
-    restart_command 'kill -USR2 {PID}'
+    restart_command "kill -USR2 {PID}"
 
-    # just sleep this until process get up status
-    # (maybe enought to puma soft restart)
-    restart_grace 10.seconds
+    restart_grace 10.seconds # just sleep this until process get up status
+                             # (maybe enought to puma soft restart)
 
-    check :cpu, every: 30, below: 80, times: 3
-    check :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/rbenv.eye

@@ -1,11 +1,11 @@
-Eye.application 'rbenv_example' do
+Eye.application "rbenv_example" do
   env 'RBENV_ROOT' => '/usr/local/rbenv', 'PATH' => "/usr/local/rbenv/shims:/usr/local/rbenv/bin:#{ENV['PATH']}"
   working_dir File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
 
-  process 'some_process' do
-    pid_file 'some.pid'
-    start_command 'ruby some.rb'
+  process "some_process" do
+    pid_file "some.pid"
+    start_command "ruby some.rb"
     daemonize true
-    stdall 'some.log'
+    stdall "some.log"
   end
 end

data/examples/sidekiq.eye

@@ -10,14 +10,14 @@ def sidekiq_process(proxy, name)
     daemonize true
     stop_signals [:USR1, 0, :TERM, 10.seconds, :KILL]
 
-    check :cpu, every: 30, below: 100, times: 5
-    check :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
 
 Eye.application :sidekiq_test do
   working_dir File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
-  env 'RAILS_ENV' => 'production'
+  env "RAILS_ENV" => 'production'
 
   sidekiq_process self, :sidekiq
 end

data/examples/stress_test.eye

@@ -3,16 +3,16 @@
 PREFIX = ENV['PRE'] || ENV['EYE_V'] || 1
 
 Eye.app :stress_test do
-  working_dir '/tmp'
+  working_dir "/tmp"
 
   100.times do |i|
     process "sleep-#{i}" do
       pid_file "sleep-#{PREFIX}-#{i}.pid"
-      start_command 'sleep 120'
+      start_command "sleep 120"
       daemonize true
 
-      checks :cpu, every: 5.seconds, below: 10, times: 5
-      checks :memory, every: 6.seconds, below: 50.megabytes, times: 5
+      checks :cpu, :every => 5.seconds, :below => 10, :times => 5
+      checks :memory, :every => 6.seconds, :below => 50.megabytes, :times => 5
     end
   end
 end

data/examples/syslog.eye

@@ -7,7 +7,7 @@ end
 
 Eye.app :syslog_test do
   process :some do
-    pid_file '/tmp/syslog_test.pid'
+    pid_file "/tmp/syslog_test.pid"
     start_command "ruby -e 'loop { p Time.now; sleep 1 }'"
     daemonize!
     stdall syslog

data/examples/test.eye

@@ -66,7 +66,7 @@ Eye.application 'test' do
   end
 
   # eventmachine process, daemonized with eye
-  process :event_machine do
+  process :event_machine do |p|
     pid_file 'em.pid'
     start_command 'ruby em.rb'
     stdout 'em.log'
@@ -86,4 +86,5 @@ Eye.application 'test' do
     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

@@ -1,29 +1,30 @@
 RUBY = 'ruby'
 BUNDLE = 'bundle'
 
-Eye.load('process_thin.rb')
+Eye.load("process_thin.rb")
 
 Eye.config do
-  logger '/tmp/eye.log'
+  logger "/tmp/eye.log"
 end
 
 Eye.app 'thin-farm' do
   working_dir File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
-  env 'RAILS_ENV' => 'production'
+  env "RAILS_ENV" => "production"
 
   # more about stop_on_delete: https://github.com/kostya/eye/wiki/About-stop_on_delete-=-true
   stop_on_delete true
 
-  trigger :flapping, times: 10, within: 1.minute
-  check :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
-    chain action: :restart, grace: 5.seconds
-    chain action: :start, grace: 0.2.seconds
+    chain :action => :restart, :grace => 5.seconds
+    chain :action => :start, :grace => 0.2.seconds
 
     (5555..5560).each do |port|
       thin self, port
     end
   end
+
 end

data/examples/triggers.eye

@@ -5,14 +5,15 @@
 # process.execute_sync(cmd, opts)
 
 Eye.config do
-  logger '/tmp/eye.log'
+  logger "/tmp/eye.log"
 end
 
 Eye.app :triggers do
+
   # Execute shell command before process start
   process :a do
-    pid_file '/tmp/a.pid'
-    start_command 'sleep 100'
+    pid_file "/tmp/a.pid"
+    start_command "sleep 100"
     daemonize true
 
     # send message async which sendxmpp, before process start
@@ -23,40 +24,41 @@ Eye.app :triggers do
 
   # Touch some file before process start, remove file after process die
   process :b do
-    pid_file '/tmp/b.pid'
-    start_command 'sleep 100'
+    pid_file "/tmp/b.pid"
+    start_command "sleep 100"
     daemonize true
 
     # before process starting, touch some file
     trigger :transition1, to: :starting, do: -> {
-      process.execute_sync 'touch /tmp/bla.file'
+      process.execute_sync "touch /tmp/bla.file"
     }
 
     # after process, crashed, or stopped, remove that file
     trigger :transition2, to: :down, do: -> {
-      process.execute_sync 'rm /tmp/bla.file'
+      process.execute_sync "rm /tmp/bla.file"
     }
   end
 
   # With restart :c process, send restart to process :a
   process :c do
-    pid_file '/tmp/c.pid'
-    start_command 'sleep 100'
+    pid_file "/tmp/c.pid"
+    start_command "sleep 100"
     daemonize true
 
     app_name = app.name
-    trigger :transition, event: :restarting, do: ->{
-      info 'send restarting to :a'
+    trigger :transition, :event => :restarting, :do => ->{
+      info "send restarting to :a"
       Eye::Control.command('restart', "#{app_name}:a")
     }
   end
 
   # process d cant start, until file /tmp/bla contains string 'bla'
   process :d do
-    pid_file '/tmp/d.pid'
-    start_command 'sleep 100'
+    pid_file "/tmp/d.pid"
+    start_command "sleep 100"
     daemonize true
 
     trigger :starting_guard, every: 5.seconds, should: -> { `cat /tmp/bla` =~ /bla/ }
   end
+
 end

data/examples/unicorn.eye

@@ -3,36 +3,37 @@
 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
+Eye.application "rails_unicorn" do
+  env "RAILS_ENV" => RAILS_ENV
 
   # unicorn requires to be `ruby` in path (for soft restart)
-  env 'PATH' => "#{File.dirname(RUBY)}:#{ENV['PATH']}"
+  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'
+  process("unicorn") do
+    pid_file "tmp/pids/unicorn.pid"
     start_command "#{RUBY} ./bin/unicorn -Dc ./config/unicorn.rb -E #{RAILS_ENV}"
-    stdall 'log/unicorn.log'
+    stdall "log/unicorn.log"
 
     # stop signals:
     # http://unicorn.bogomips.org/SIGNALS.html
     stop_signals [:TERM, 10.seconds]
 
     # soft restart
-    restart_command 'kill -USR2 {PID}'
+    restart_command "kill -USR2 {PID}"
 
-    check :cpu, every: 30, below: 80, times: 3
-    check :memory, every: 30, below: 150.megabytes, times: [3, 5]
+    check :cpu, :every => 30, :below => 80, :times => 3
+    check :memory, :every => 30, :below => 150.megabytes, :times => [3,5]
 
     start_timeout 100.seconds
     restart_grace 30.seconds
 
     monitor_children do
-      stop_command 'kill -QUIT {PID}'
-      check :cpu, every: 30, below: 80, times: 3
-      check :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
+
 end