ace-eye 0.6.1

data/bin/runner

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+require 'eye'
+
+# Local version of eye
+#  which looking for Eyefile
+#  like foreman
+
+unless Eye::Local.eyefile
+  puts "Not found Eyefile"
+  exit 1
+end
+
+Eye::Local.dir = File.dirname(Eye::Local.eyefile)
+Eye::Local.local_runner = true
+Eye::Cli.start

data/examples/dependency.eye

@@ -0,0 +1,17 @@
+# process dependencies :b -> :a
+
+Eye.app :dependency do
+  process(:a) do
+    start_command "sleep 100"
+    daemonize true
+    pid_file "/tmp/test_process_a.pid"
+  end
+
+  process(:b) do
+    start_command "sleep 100"
+    daemonize true
+    pid_file "/tmp/test_process_b.pid"
+    depend_on :a
+  end
+
+end

data/examples/notify.eye

@@ -0,0 +1,19 @@
+# Notify example
+
+Eye.config do
+  mail :host => "mx.some.host", :port => 25, :domain => "some.host"
+  contact :errors, :mail, 'error@some.host'
+  contact :dev, :mail, 'dev@some.host'
+end
+
+Eye.application :some do
+  notify :errors
+
+  process :some_process do
+    notify :dev, :info
+    pid_file "1.pid"
+
+    #...
+  end
+
+end

data/examples/plugin/README.md

@@ -0,0 +1,15 @@
+Eye Plugin Example
+------------------
+
+This plugin adds reactor which try to reads command from file "/tmp/cmd.txt" every 1.second (then execute it and delete file). Also plugin add trigger to save every process state transition into "/tmp/saver.log".
+
+To test it:
+
+    bundle exec eye l examples/plugin/main.eye
+    tail -f /tmp/eye.log
+    tail -f /tmp/saver.log
+    echo 'restart' > /tmp/cmd.txt
+
+Also, here http example of gem:
+
+    https://github.com/kostya/eye-http

data/examples/plugin/main.eye

@@ -0,0 +1,15 @@
+Eye.load('./plugin.rb')
+
+Eye.config do
+  logger "/tmp/eye.log"
+  enable_reactor(1.second, "/tmp/cmd.txt")
+  enable_saver("/tmp/saver.log")
+end
+
+Eye.app :app do
+  process :process do
+    pid_file "/tmp/p.pid"
+    start_command "sleep 10"
+    daemonize true
+  end
+end

data/examples/plugin/plugin.rb

@@ -0,0 +1,63 @@
+class Reactor
+  include Celluloid
+
+  def initialize(interval, filename)
+    @interval = interval
+    @filename = filename
+    every(@interval) do
+      info "check file #{@filename}"
+      if cmd = read_file
+        execute_command cmd
+      end
+    end
+  end
+
+  def read_file
+    if File.exists?(@filename)
+      cmd = File.read(@filename).chop
+      File.delete(@filename) rescue nil
+      cmd
+    end
+  end
+
+  def execute_command(cmd)
+    Eye::Control.command(cmd, 'all') if %w{restart start stop}.include?(cmd)
+  end
+end
+
+class Saver < Eye::Trigger::Custom
+  param :log_name, String, true
+
+  def check(trans)
+    tlogger.info "#{process.full_name} transition from #{trans.from_name} to #{trans.to_name}"
+  end
+
+  def tlogger
+    @tlogger ||= Logger.new(log_name)
+  end
+end
+
+def reactor
+  Celluloid::Actor[:reactor]
+end
+
+# Extend config options, add enable_reactor
+class Eye::Dsl::ConfigOpts
+  def enable_reactor(*args)
+    @config[:reactor] = args
+  end
+
+  def enable_saver(save_log)
+    Eye.application '__default__' do
+      trigger :saver, :log_name => save_log
+    end
+  end
+end
+
+# extend controller to execute method, and config loads
+class Eye::Controller
+  def set_opt_reactor(args)
+    reactor.terminate if reactor
+    Celluloid::Actor[:reactor] = Reactor.supervise(*args)
+  end
+end

data/examples/process_thin.rb

@@ -0,0 +1,29 @@
+
+def thin(proxy, port)
+  name = "thin-#{port}"
+
+  opts = [
+    "-l thins.log",
+    "-p #{port}",
+    "-P #{name}.pid",
+    "-d",
+    "-R thin.ru",
+    "--tag #{proxy.app.name}.#{proxy.name}",
+    "-t 60",
+    "-e #{proxy.env["RAILS_ENV"]}",
+    "-c #{proxy.working_dir}",
+    "-a 127.0.0.1"
+  ]
+
+  proxy.process(name) do
+    pid_file "#{name}.pid"
+
+    start_command "#{BUNDLE} exec thin start #{opts * ' '}"
+    stop_signals [:QUIT, 2.seconds, :TERM, 1.seconds, :KILL]
+
+    stdall "thin.stdall.log"
+
+    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/processes/em.rb

@@ -0,0 +1,57 @@
+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 "QUIT" do
+  puts "quit signal, stopping"
+  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/processes/thin.ru

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+require 'sinatra'
+
+class Test < Sinatra::Base
+
+  get '/hello' do
+    sleep 0.5
+    "Hello World!"
+  end
+end
+
+run Test.new

data/examples/puma.eye

@@ -0,0 +1,29 @@
+BUNDLE = 'bundle'
+RAILS_ENV = 'production'
+ROOT = File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
+
+Eye.config do
+  logger "#{ROOT}/eye.log"
+end
+
+Eye.application :puma do
+  env 'RAILS_ENV' => RAILS_ENV
+  working_dir ROOT
+  trigger :flapping, :times => 10, :within => 1.minute
+
+  process :puma do
+    daemonize true
+    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_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]
+  end
+end