eye 0.2.4 → 0.3

data/spec/dsl/sub_procs_spec.rb

@@ -1,93 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "sub procs" do
-  it "include lambda" do
-    conf = <<-E
-      proc = lambda do |proxy|
-        proxy.working_dir "/tmp"
-      end
-
-      Eye.application("bla") do
-        include proc        
-      end
-    E
-    Eye::Dsl.parse_apps(conf).should == {"bla" => {:working_dir=>"/tmp", :name => "bla"}}
-  end
-
-  it "include lambda with arg" do
-    conf = <<-E
-      proc = lambda do |proxy, arg|
-        proxy.working_dir arg
-      end
-
-      Eye.application("bla") do
-        include proc, "1"
-      end
-    E
-    Eye::Dsl.parse_apps(conf).should == {"bla" => {:name=>"bla", :working_dir=>"1"}}
-  end
-
-  it "include proc" do
-    conf = <<-E
-      proc = Proc.new do
-        working_dir "/tmp"
-      end
-
-      Eye.application("bla") do
-        include proc        
-      end
-    E
-    Eye::Dsl.parse_apps(conf).should == {"bla" => {:working_dir=>"/tmp", :name => "bla"}}
-  end
-
-  it "include proc with arg" do
-    conf = <<-E
-      proc = Proc.new do |proxy, arg|
-        proxy.working_dir arg
-      end
-
-      Eye.application("bla") do
-        include proc, "1"
-      end
-    E
-    Eye::Dsl.parse_apps(conf).should == {"bla" => {:name=>"bla", :working_dir=>"1"}}
-  end
-
-  it "include method" do
-    conf = <<-E
-      def add_process(proxy)
-        working_dir "/tmp"
-      end
-
-      Eye.application("bla") do
-        include method(:add_process)
-      end
-    E
-    Eye::Dsl.parse_apps(conf).should == {"bla" => {:working_dir=>"/tmp", :name => "bla"}}
-  end
-
-  it "include method with arg" do
-    conf = <<-E
-      def add_process(proxy, arg)
-        working_dir arg
-      end
-
-      Eye.application("bla") do
-        include method(:add_process), "1"
-      end
-    E
-    Eye::Dsl.parse_apps(conf).should == {"bla" => {:name=>"bla", :working_dir=>"1"}}
-  end
-
-  it "include part of code" do
-    Eye::Dsl.parse_apps(nil, fixture("dsl/include_test.eye")).should == {
-      "test" => {:name=>"test", :environment=>{"a"=>"b"}, 
-      :groups=>{"__default__"=>{:name=>"__default__", :environment=>{"a"=>"b"}, :application=>"test", 
-      :processes=>{"bla"=>{:name=>"bla", :environment=>{"a"=>"b"}, :application=>"test", :group=>"__default__", :pid_file=>"10"}}}}}}
-  end
-
-  it "include part of code 2 times" do
-    Eye::Dsl.parse_apps(nil, fixture("dsl/include_test2.eye")).should == {"test2" => {:name=>"test2", :groups=>{"ha"=>{:name=>"ha", :application=>"test2", :environment=>{"a"=>"b"}, :processes=>{"bla"=>{:name=>"bla", :application=>"test2", :environment=>{"a"=>"b"}, :group=>"ha", :pid_file=>"10"}}}}}}
-  end
-
-end

data/spec/dsl/with_server_spec.rb

@@ -1,128 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "with_server feature" do
-
-  it "should load matched by string process" do
-    stub(Eye::System).host{ "server1" }
-
-    conf = <<-E
-      Eye.application("bla") do
-        with_server "server1" do
-          process("1"){ pid_file "1.pid" }
-        end
-
-        with_server "server2" do
-          process("2"){ pid_file "2.pid" }
-        end
-      end
-    E
-
-    Eye::Dsl.parse_apps(conf).should == {"bla"=>{:name => "bla", :groups=>{"__default__"=>{:name => "__default__", :application => "bla", :processes=>{"1"=>{:pid_file=>"1.pid", :application=>"bla", :group=>"__default__", :name=>"1"}}}}}}
-  end
-
-  it "should another host conditions" do
-    stub(Eye::System).host{ "server1" }
-
-    conf = <<-E
-      Eye.application("bla") do
-        with_server %w{server1 server2} do
-          process("1"){ pid_file "1.pid" }
-
-          if Eye::SystemResources == 'server2'
-            process("2"){ pid_file "2.pid" }
-          end
-        end
-      end
-    E
-
-    Eye::Dsl.parse_apps(conf).should == {"bla"=>{:name => "bla", :groups=>{"__default__"=>{:name => "__default__", :application => "bla", :processes=>{"1"=>{:pid_file=>"1.pid", :application=>"bla", :group=>"__default__", :name=>"1"}}}}}}
-  end
-
-  it "should behaves like scoped" do
-    stub(Eye::System).host{ "server1" }
-
-    conf = <<-E
-      Eye.application("bla") do
-        env "A" => "B"
-        with_server /server1/ do
-          env "A" => "C"
-          group(:a){}
-        end
-
-        group(:b){}
-      end
-    E
-
-    Eye::Dsl.parse_apps(conf).should == {
-      "bla" => {:name=>"bla", :environment=>{"A"=>"B"}, 
-        :groups=>{
-          "a"=>{:name=>"a", :environment=>{"A"=>"C"}, :application=>"bla", :processes=>{}}, 
-          "b"=>{:name=>"b", :environment=>{"A"=>"B"}, :application=>"bla", :processes=>{}}}}}
-  end
-
-  describe "matches" do
-    subject{ Eye::Dsl::Opts.new }
-
-    it "match string" do
-      stub(Eye::System).host{ "server1" }
-      subject.with_server("server1").should == true
-      subject.with_server("server2").should == false
-      subject.with_server('').should == true
-      subject.with_server(nil).should == true
-    end
-
-    it "match array" do
-      stub(Eye::System).host{ "server1" }
-      subject.with_server(%w{ server1 server2}).should == true
-      subject.with_server(%w{ server2 server3}).should == false
-    end
-
-    it "match regexp" do
-      stub(Eye::System).host{ "server1" }
-      subject.with_server(%r{server}).should == true
-      subject.with_server(%r{myserver}).should == false
-    end
-  end
-
-  describe "helpers" do
-    it "hostname on with server" do
-      conf = <<-E
-        Eye.application("bla"){ 
-          with_server('muga_server') do
-            working_dir "/tmp"
-          end
-        }
-      E
-      Eye::Dsl.parse_apps(conf).should == {"bla" => {:name => "bla"}}
-    end
-
-    it "with_server work" do
-      Eye::System.host = 'mega_server'
-
-      conf = <<-E
-        Eye.application("bla"){ 
-          with_server('mega_server') do
-            group :blo do
-              working_dir "/tmp"
-            end            
-          end
-        }
-      E
-      Eye::Dsl.parse_apps(conf).should == {"bla" => {:name=>"bla", :groups=>{"blo"=>{:name=>"blo", :application=>"bla", :working_dir=>"/tmp", :processes=>{}}}}}
-    end
-
-    it "hostname work" do
-      Eye::System.host = 'supa_server'
-
-      conf = <<-E
-        Eye.application("bla"){ 
-          working_dir "/tmp"
-          env "HOST" => hostname
-        }
-      E
-      Eye::Dsl.parse_apps(conf).should == {"bla" => {:name => "bla", :working_dir=>"/tmp", :environment=>{"HOST"=>"supa_server"}}}
-    end
-
-  end
-
-end

data/spec/example/em.rb

@@ -1,57 +0,0 @@
-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
-  `rm /tmp/em_test_sock_spec` rescue nil
-end
-
-EM.run do
-  EM.start_server '127.0.0.1', 33231, Echo
-  EM.start_server '127.0.0.1', 33232, EchoObj
-  EM.start_server "/tmp/em_test_sock_spec", nil, Echo
-  puts 'started'
-end

data/spec/example/forking.rb

@@ -1,20 +0,0 @@
-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/spec/example/sample.rb

@@ -1,154 +0,0 @@
-#!/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
-
-  opts.on( '-T', '--no_terminate', 'catch terminate signal and not die' ) do
-    options[:no_terminate] = true
-  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
-
-if options[:no_terminate]
-  trap("TERM") do
-    puts "TERM signal! and we not die O_o"
-  end
-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