eye 0.1.11

data/spec/controller/group_spec.rb

@@ -0,0 +1,110 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Eye::Group" do
+
+  describe "Chain calls" do
+
+    it "should call chain_schedule for start" do
+      @g = Eye::Group.new('gr', {:chain => {:start => {:type => :async, :command => :start, :grace => 7}}})
+      mock(@g).chain_schedule(:async, 7, :start)
+      @g.start
+    end
+
+    it "should call chain_schedule for start, with type sync" do
+      @g = Eye::Group.new('gr', {:chain => {:start => {:type => :sync, :command => :start, :grace => 7}}})
+      mock(@g).chain_schedule(:sync, 7, :start)
+      @g.start
+    end
+
+    it "config for start and restart, use both" do
+      @g = Eye::Group.new('gr', {:chain => {:start => {:type => :async, :command => :start, :grace => 7}, :restart => {:type => :sync, :command => :restart, :grace => 8}}})
+      mock(@g).chain_schedule(:async, 7, :start)
+      @g.start
+
+      mock(@g).chain_schedule(:sync, 8, :restart)
+      @g.restart
+    end
+
+    it "should use options type" do
+      @g = Eye::Group.new('gr', {:chain => {:start => {:type => :sync, :command => :start}}})
+      mock(@g).chain_schedule(:sync, Eye::Group::DEFAULT_CHAIN, :start)
+      @g.start
+    end
+
+    it "with empty grace, should call default grace 0" do
+      @g = Eye::Group.new('gr', {:chain => {:start => {:command => :start}}})
+      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :start)
+      @g.start
+    end
+
+    it "chain options for restart, but called start, should call chain but with default options" do
+      @g = Eye::Group.new('gr', {:chain => {:start => {:command => :restart}}})
+      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
+      @g.restart
+    end
+
+    it "restart without grace, should call default grace 0" do
+      @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart}}})
+      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
+      @g.restart
+    end
+
+    it "restart with invalid type, should call with async" do
+      @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart, :type => [12324]}}})
+      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
+      @g.restart
+    end
+
+    it "restart with invalid grace, should call default grace 0" do
+      @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart, :grace => []}}})
+      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
+      @g.restart
+    end
+
+    it "restart with invalid grace, should call default grace 0" do
+      @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart, :grace => :some_error}}})
+      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
+      @g.restart
+    end
+
+    it "restart with empty config, should call chain_schedule" do
+      @g = Eye::Group.new('gr', {})
+      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
+      @g.restart
+    end
+
+    it "when chain clearing by force" do
+      @g = Eye::Group.new('gr', {:chain => {:start => {:command => :start, :grace => 0}, :restart => {:command => :restart, :grace => 0}}})      
+      mock(@g).chain_schedule(:async, 0, :monitor)
+      @g.monitor
+
+      mock(@g).chain_schedule(:async, 0, :restart)
+      @g.restart
+
+      mock(@g).chain_schedule(:async, 0, :start)
+      @g.start
+    end
+
+    it "with params" do
+      @g = Eye::Group.new('gr', {})
+      mock(@g).async_schedule(:signal, 15)
+      @g.signal(15)
+    end
+
+    describe "monitor using chain as start" do
+      it "monitor call chain" do
+        @g = Eye::Group.new('gr', {:chain => {:start => {:command => :start, :grace => 3}}})
+        mock(@g).chain_schedule(:async, 3, :monitor)
+        @g.monitor
+      end
+
+      it "monitor not call chain" do
+        @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart, :grace => 3}}})
+        mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :monitor)
+        @g.monitor
+      end
+    end
+
+  end
+
+end

data/spec/controller/intergration_spec.rb

@@ -0,0 +1,327 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Intergration" do
+  before :each do
+    @c = Eye::Controller.new
+    @c.load(fixture("dsl/integration.eye"))
+    @processes = @c.all_processes
+    @p1 = @processes.detect{|c| c.name == 'sample1'}
+    @p2 = @processes.detect{|c| c.name == 'sample2'}
+    @p3 = @processes.detect{|c| c.name == 'forking'}
+    @samples = @c.all_groups.detect{|c| c.name == 'samples'}
+    sleep 10 # to ensure that all processes started
+
+    @processes.size.should == 3
+    @processes.map{|c| c.state_name}.uniq.should == [:up]
+    @childs = @p3.childs.keys rescue []
+
+    @c.info_string.split("\n").size.should == 8
+    @c.info_string.strip.size.should > 100
+  end
+
+  after :each do
+    @processes.each do |p|
+      p.schedule(:stop) if p.alive?
+    end
+    sleep 5
+    @processes.each do |process|
+      force_kill_process(process) if process.alive?
+    end
+
+    force_kill_pid(@old_pid1)
+    force_kill_pid(@old_pid2)
+    force_kill_pid(@old_pid3)
+    (@childs || []).each do |pid|
+      force_kill_pid(pid)
+    end
+  end
+
+  it "restart process group samples" do
+    @old_pid1 = @p1.pid
+    @old_pid2 = @p2.pid
+    @old_pid3 = @p3.pid
+    @c.send_command(:restart, "samples")
+    sleep 11 # while they restarting
+
+    @processes.map{|c| c.state_name}.uniq.should == [:up]
+    @p1.pid.should_not == @old_pid1
+    @p2.pid.should_not == @old_pid2
+    @p3.pid.should == @old_pid3
+  end
+
+  it "restart process" do
+    @old_pid1 = @p1.pid
+    @old_pid2 = @p2.pid
+    @old_pid3 = @p3.pid
+    @c.send_command(:restart, "sample1")
+    sleep 10 # while they restarting
+
+    @processes.map{|c| c.state_name}.uniq.should == [:up]
+    @p1.pid.should_not == @old_pid1
+    @p2.pid.should == @old_pid2
+    @p3.pid.should == @old_pid3
+  end
+
+  it "restart process forking" do
+    @old_pid1 = @p1.pid
+    @old_pid2 = @p2.pid
+    @old_pid3 = @p3.pid
+    @c.send_command(:restart, "forking")
+    sleep 11 # while they restarting
+
+    @processes.map{|c| c.state_name}.uniq.should == [:up]
+    @p1.pid.should == @old_pid1
+    @p2.pid.should == @old_pid2
+    @p3.pid.should_not == @old_pid3
+
+    @p1.last_scheduled_reason.should == 'monitor by user'
+    @p3.last_scheduled_reason.should == 'restart by user'
+  end
+
+  it "restart missing" do
+    @old_pid1 = @p1.pid
+    @old_pid2 = @p2.pid
+    @old_pid3 = @p3.pid
+    @c.send_command(:restart, "blabla").should == []
+    sleep 1
+    @processes.map{|c| c.state_name}.uniq.should == [:up]
+    @p1.pid.should == @old_pid1
+    @p2.pid.should == @old_pid2
+    @p3.pid.should == @old_pid3
+  end
+
+  describe "chain" do
+    it "restart group with chain sync" do
+      @samples.config.merge!(:chain => C.restart_sync)
+
+      @old_pid1 = @p1.pid
+      @old_pid2 = @p2.pid
+      @old_pid3 = @p3.pid
+      @c.send_command(:restart, "samples")
+      sleep 15 # while they restarting
+
+      @processes.map{|c| c.state_name}.uniq.should == [:up]
+      @p1.pid.should_not == @old_pid1
+      @p2.pid.should_not == @old_pid2
+      @p3.pid.should == @old_pid3
+
+      r1 = @p1.states_history.detect{|c| c[:state] == :restarting}[:at]
+      r2 = @p2.states_history.detect{|c| c[:state] == :restarting}[:at]
+
+      # >8 because, grace start, and grace stop added
+      (r2 - r1).should > 8
+    end
+
+    it "restart group with chain async" do
+      @samples.config.merge!(:chain => C.restart_async)
+
+      @old_pid1 = @p1.pid
+      @old_pid2 = @p2.pid
+      @old_pid3 = @p3.pid
+      @c.send_command(:restart, "samples")
+      sleep 15 # while they restarting
+
+      @processes.map{|c| c.state_name}.uniq.should == [:up]
+      @p1.pid.should_not == @old_pid1
+      @p2.pid.should_not == @old_pid2
+      @p3.pid.should == @old_pid3
+
+      r1 = @p1.states_history.detect{|c| c[:state] == :restarting}[:at]
+      r2 = @p2.states_history.detect{|c| c[:state] == :restarting}[:at]
+
+      # restart sended, in 5 seconds to each
+      (r2 - r1).should be_within(0.2).of(5)
+    end
+
+    it "if processes dead in chain restart, nothing raised" do
+      @samples.config.merge!(:chain => C.restart_async)
+
+      @old_pid1 = @p1.pid
+      @old_pid2 = @p2.pid
+      @old_pid3 = @p3.pid
+      @c.send_command(:restart, "samples")
+      sleep 3
+
+      # in the middle of the process, we kill all processes
+      @p1.terminate
+      @p2.terminate
+
+      sleep 3
+
+      # nothing happens
+      @samples.alive?.should == true
+    end
+  end
+
+  it "stop group" do
+    @old_pid1 = @p1.pid
+    @old_pid2 = @p2.pid
+    @old_pid3 = @p3.pid
+    @c.send_command(:stop, "samples")
+    sleep 7 # while they stopping
+
+    @p1.state_name.should == :unmonitored
+    @p2.state_name.should == :unmonitored
+    @p3.state_name.should == :up
+
+    Eye::System.pid_alive?(@old_pid1).should == false
+    Eye::System.pid_alive?(@old_pid2).should == false
+    Eye::System.pid_alive?(@old_pid3).should == true
+
+    sth = @p1.states_history.last
+    sth[:reason].should == 'stop by user'
+    sth[:state].should == :unmonitored
+  end
+
+  it "stop process" do
+    @old_pid1 = @p1.pid
+    @old_pid2 = @p2.pid
+    @old_pid3 = @p3.pid
+
+    @c.send_command(:stop, "sample1")
+    sleep 7 # while they stopping
+
+    @p1.state_name.should == :unmonitored
+    @p2.state_name.should == :up
+    @p3.state_name.should == :up
+
+    Eye::System.pid_alive?(@old_pid1).should == false
+    Eye::System.pid_alive?(@old_pid2).should == true
+    Eye::System.pid_alive?(@old_pid3).should == true
+  end
+
+  it "unmonitor process" do
+    @old_pid1 = @p1.pid
+    @old_pid2 = @p2.pid
+    @old_pid3 = @p3.pid
+
+    @c.send_command(:unmonitor, "sample1").should == ["int:samples:sample1"]
+    sleep 7 # while they stopping
+
+    @p1.state_name.should == :unmonitored
+    @p2.state_name.should == :up
+    @p3.state_name.should == :up
+
+    Eye::System.pid_alive?(@old_pid1).should == true
+    Eye::System.pid_alive?(@old_pid2).should == true
+    Eye::System.pid_alive?(@old_pid3).should == true
+  end
+
+  it "send signal to process throught all schedules" do
+    mock(@p1).signal('usr2')
+    mock(@p2).signal('usr2')
+    mock(@p3).signal('usr2')
+
+    @c.signal('usr2', "int").should == ["int"]
+    sleep 3 # while they gettings
+
+    @p1.last_scheduled_command.should == :signal
+    @p1.last_scheduled_reason.should == 'signal by user'
+
+    mock(@p1).signal('usr1')
+    @c.signal('usr1', 'sample1')
+    sleep 0.5
+  end
+
+  describe "delete" do
+    it "delete group not monitoring anymore" do
+      @old_pid1 = @p1.pid
+      @old_pid2 = @p2.pid
+      @old_pid3 = @p3.pid
+
+      @c.send_command(:delete, "samples").should == ["int:samples"]
+      sleep 7 # while 
+
+      @c.all_processes.should == [@p3]
+      @c.all_groups.map(&:name).should == ['__default__']
+
+      Eye::System.pid_alive?(@old_pid1).should == true
+      Eye::System.pid_alive?(@old_pid2).should == true
+      Eye::System.pid_alive?(@old_pid3).should == true
+
+      Eye::System.send_signal(@old_pid1)
+      sleep 0.5
+      Eye::System.pid_alive?(@old_pid1).should == false
+
+      # noone up this
+      sleep 2
+      Eye::System.pid_alive?(@old_pid1).should == false
+    end
+
+    it "delete process not monitoring anymore" do
+      @old_pid1 = @p1.pid
+      @old_pid2 = @p2.pid
+      @old_pid3 = @p3.pid
+
+      @c.send_command(:delete, "sample1")
+      sleep 7 # while 
+
+      @c.all_processes.map(&:name).sort.should == %w{forking sample2}
+      @c.all_groups.map(&:name).sort.should == %w{__default__ samples}
+      @c.group_by_name('samples').processes.full_size.should == 1
+      @c.group_by_name('samples').processes.map(&:name).should == %w{sample2}
+
+      Eye::System.pid_alive?(@old_pid1).should == true
+      Eye::System.pid_alive?(@old_pid2).should == true
+      Eye::System.pid_alive?(@old_pid3).should == true
+
+      Eye::System.send_signal(@old_pid1)
+      sleep 0.5
+      Eye::System.pid_alive?(@old_pid1).should == false
+    end
+
+    it "delete application" do
+      @old_pid1 = @p1.pid
+      @old_pid2 = @p2.pid
+      @old_pid3 = @p3.pid
+
+      @c.send_command(:delete, "int")
+      sleep 7 # while 
+
+      @c.all_processes.should == []
+      @c.all_groups.should == []
+      @c.applications.should == []
+
+      Eye::System.pid_alive?(@old_pid1).should == true
+      Eye::System.pid_alive?(@old_pid2).should == true
+      Eye::System.pid_alive?(@old_pid3).should == true
+
+      Eye::System.send_signal(@old_pid1)
+      sleep 0.5
+      Eye::System.pid_alive?(@old_pid1).should == false
+
+      actors = Celluloid::Actor.all.map(&:class)
+      actors.should_not include(Eye::Utils::CelluloidChain)
+      actors.should_not include(Eye::Process)
+      actors.should_not include(Eye::Group)
+      actors.should_not include(Eye::Application)
+      actors.should_not include(Eye::Checker::Memory)
+    end
+
+    it "delete by mask" do
+      @old_pid1 = @p1.pid
+      @old_pid2 = @p2.pid
+      @old_pid3 = @p3.pid
+
+      @c.send_command(:delete, "sam*").should == ["int:samples"]
+      sleep 7 # while 
+
+      @c.all_processes.should == [@p3]
+      @c.all_groups.map(&:name).should == ['__default__']
+
+      Eye::System.pid_alive?(@old_pid1).should == true
+      Eye::System.pid_alive?(@old_pid2).should == true
+      Eye::System.pid_alive?(@old_pid3).should == true
+
+      Eye::System.send_signal(@old_pid1)
+      sleep 0.5
+      Eye::System.pid_alive?(@old_pid1).should == false
+
+      # noone up this
+      sleep 2
+      Eye::System.pid_alive?(@old_pid1).should == false
+    end
+  end
+
+
+end

data/spec/controller/load_spec.rb

@@ -0,0 +1,326 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Eye::Controller::Load" do
+  subject{ Eye::Controller.new }
+
+  it "blank" do
+    subject.load.should == {:error => true, :message => "config file '' not found!"}
+  end
+
+  it "not exists file" do
+    subject.load("/asdf/asd/fasd/fas/df/sfd").should == {:error => true, :message => "config file '/asdf/asd/fasd/fas/df/sfd' not found!"}
+  end
+
+  it "load 1 app" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.short_tree.should == {
+      "app1"=>{
+        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
+        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
+        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
+      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}}
+  end
+
+  it "load correctly application, groups for full_names processes" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+
+    p1 = subject.process_by_name('p1')
+    p1[:application].should == 'app1'
+    p1[:group].should == 'gr1'
+    p1.name.should == 'p1'
+    p1.full_name.should == 'app1:gr1:p1'
+
+    gr1 = subject.group_by_name 'gr1'
+    gr1.full_name.should == 'app1:gr1'
+
+    g4 = subject.process_by_name('g4')
+    g4[:application].should == 'app1'
+    g4[:group].should == '__default__'
+    g4.name.should == 'g4'
+    g4.full_name.should == 'app1:g4'
+  end
+
+  it "load + 1new app" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.short_tree.should == {
+      "app1"=>{
+        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
+        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
+        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
+      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}}
+
+    subject.load(fixture("dsl/load2.eye")).should include(error: false)
+
+    subject.short_tree.should == {
+      "app1"=>{
+        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
+        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
+        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
+      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}, 
+      "app3"=>{"__default__"=>{"e1"=>"/tmp/app3-e1.pid"}}}
+  end
+
+  it "load 1 changed app" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.load(fixture("dsl/load2.eye")).should include(error: false)
+
+    p = subject.process_by_name('e1')
+    p[:daemonize].should == false
+
+    proxy(p).schedule :update_config, is_a(Hash), is_a(String)
+    dont_allow(p).schedule :monitor
+
+    subject.load(fixture("dsl/load3.eye")).should include(error: false)
+
+    subject.short_tree.should == {
+      "app1"=>{
+        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
+        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
+        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
+      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}, 
+      "app3"=>{"wow"=>{"e1"=>"/tmp/app3-e1.pid"}}}
+
+    sleep 0.1
+    p2 = subject.process_by_name('e1')
+    p2[:daemonize].should == true
+
+    p.object_id.should == p2.object_id
+  end
+
+  it "load -> delete -> load" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.load(fixture("dsl/load2.eye")).should include(error: false)
+    subject.command(:delete, 'app3')
+    subject.load(fixture("dsl/load3.eye")).should include(error: false)
+
+    subject.short_tree.should == {
+      "app1"=>{
+        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
+        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
+        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
+      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}, 
+      "app3"=>{"wow"=>{"e1"=>"/tmp/app3-e1.pid"}}}
+  end
+
+  it "load + 1 app, and pid_file crossed" do
+    subject.load(fixture("dsl/load2.eye")).should include(error: false)
+    subject.load(fixture("dsl/load4.eye")).should include(:error => true, :message => "dublicate pid_files: {\"/tmp/app3-e1.pid\"=>2}")
+
+    subject.short_tree.should == {
+      "app3"=>{"__default__"=>{"e1"=>"/tmp/app3-e1.pid"}}}
+  end
+
+  it "check syntax" do
+    subject.load(fixture("dsl/load2.eye")).should include(error: false)
+    subject.check(fixture("dsl/load4.eye")).should include(:error => true, :message => "dublicate pid_files: {\"/tmp/app3-e1.pid\"=>2}")
+  end
+
+  it "check explain" do
+    res = subject.explain(fixture("dsl/load2.eye"))
+    res[:error].should == false
+    res[:config].is_a?(Hash).should == true
+  end
+
+  it "process and groups disappears" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.group_by_name('gr1').processes.full_size.should == 2
+
+    subject.load(fixture("dsl/load5.eye")).should include(error: false)
+    sleep 0.5
+
+    group_actors = Celluloid::Actor.all.select{|c| c.class == Eye::Group }
+    process_actors = Celluloid::Actor.all.select{|c| c.class == Eye::Process }
+
+    subject.short_tree.should == {
+      "app1"=>{"gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid"}},
+      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}}
+
+    group_actors.map{|a| a.name}.sort.should == %w{__default__ gr1}
+    process_actors.map{|a| a.name}.sort.should == %w{p1 z1}
+
+    subject.group_by_name('gr1').processes.full_size.should == 1
+
+    # terminate 1 action
+    subject.process_by_name('p1').terminate
+    subject.info_string.should be_a(String)
+  end
+
+  it "swap groups" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.load(fixture("dsl/load6.eye")).should include(error: false)
+
+    subject.short_tree.should == {
+      "app1" => {
+        "gr2"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
+        "gr1"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
+        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}},
+      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}}
+  end
+
+  it "two configs with same pids (should validate final config)" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.load(fixture("dsl/load2*.eye")).should == {:error => true, :message=>"dublicate pid_files: {\"/tmp/app3-e1.pid\"=>2}"}    
+  end
+
+  it "two configs with same pids (should validate final config)" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    subject.load(fixture("dsl/load2.eye")).should include(error: false)
+    subject.load(fixture("dsl/load2_*.eye")).should == {:error => true, :message=>"dublicate pid_files: {\"/tmp/app3-e1.pid\"=>2}"}
+  end
+
+  it "dups of pid_files, but they different with expand" do
+    subject.load(fixture("dsl/load2_dup2.eye")).should include(error: false)
+  end
+
+  it "dups of names but in different scopes" do
+    subject.load(fixture("dsl/load_dup_ex_names.eye")).should include(error: false)
+  end
+
+  describe "configs" do
+    after(:each){ set_glogger }
+
+    it "load logger" do
+      subject.load(fixture("dsl/load_logger.eye")).should include(error: false)
+      Eye::Logger.dev.should == "/tmp/1.log"
+    end
+
+    it "set logger when load multiple configs" do
+      subject.load(fixture("dsl/load_logger{,2}.eye")).should include(error: false)
+      Eye::Logger.dev.should == "/tmp/1.log"
+    end
+
+    it "should corrent load config section" do
+      subject.load(fixture("dsl/configs/{1,2}.eye")).should include(error: false)
+      Eye::Logger.dev.should == "/tmp/a.log"
+      subject.current_config[:config].should == {:logger=>"/tmp/a.log", :http=>{:enable=>true}}
+
+      subject.load(fixture("dsl/configs/3.eye")).should include(error: false)
+      Eye::Logger.dev.should == "/tmp/a.log"
+      subject.current_config[:config].should == {:logger=>"/tmp/a.log", :http=>{:enable=>false}}
+
+      subject.load(fixture("dsl/configs/4.eye")).should include(error: false)
+      Eye::Logger.dev.should == nil
+      subject.current_config[:config].should == {:logger=>'', :http=>{:enable=>false}}
+
+      subject.load(fixture("dsl/configs/2.eye")).should include(error: false)
+      Eye::Logger.dev.should == nil
+      subject.current_config[:config].should == {:logger=>'', :http=>{:enable=>true}}
+    end
+  end
+
+
+  it "load folder" do
+    subject.load(fixture("dsl/load_folder/")).should include(error: false)
+    subject.short_tree.should == {       
+      "app3" => {"wow"=>{"e1"=>"/tmp/app3-e1.pid"}},
+      "app4" => {"__default__"=>{"e2"=>"/tmp/app4-e2.pid"}}
+    }
+  end
+  
+  it "load folder with error" do
+    subject.load(fixture("dsl/load_error_folder/")).should include(error: true)
+  end
+
+  it "load files by mask" do
+    subject.load(fixture("dsl/load_folder/*.eye")).should include(error: false)
+    subject.short_tree.should == {       
+      "app3" => {"wow"=>{"e1"=>"/tmp/app3-e1.pid"}},
+      "app4" => {"__default__"=>{"e2"=>"/tmp/app4-e2.pid"}}
+    }
+  end
+  
+  it "load files by mask with error" do
+    subject.load(fixture("dsl/load_error_folder/*.eye")).should include(error: true)
+  end
+
+  it "load not files with mask" do
+    subject.load(fixture("dsl/load_folder/*.bla")).should include(error: true) 
+  end
+
+  it "bad mask" do
+    subject.load(" asdf asdf afd d").should == {:error => true, :message => "config file ' asdf asdf afd d' not found!"}
+  end
+
+  it "group update it settings" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+    app = subject.application_by_name('app1')
+    gr = subject.group_by_name('gr2')
+    gr.config[:chain].should == {:restart => {:grace=>0.5, :action=>:restart}, :start => {:grace=>0.5, :action=>:start}}
+
+    subject.load(fixture("dsl/load6.eye")).should include(error: false)
+    sleep 1
+
+    gr.config[:chain].should == {:restart => {:grace=>1.0, :action=>:restart}, :start => {:grace=>1.0, :action=>:start}}
+  end
+
+  it "load multiple apps with cross constants" do
+    subject.load(fixture('dsl/subfolder{2,3}.eye')) 
+    subject.process_by_name('e1')[:working_dir].should == '/tmp'
+    subject.process_by_name('e2')[:working_dir].should == 'sub3'
+
+    subject.process_by_name('e3')[:working_dir].should == '/tmp'
+    subject.process_by_name('e4')[:working_dir].should == 'sub2'
+  end
+
+  it "raised load" do
+    subject.load(fixture("dsl/load_error.eye")).should == {error: true, message: "No such file or directory - /asd/fasd/fas/df/asd/fas/df/d"}
+    Eye.logger = $logger_path
+  end
+
+  describe "synchronize groups" do
+    it "correctly schedule monitor for groups and processes" do
+      subject.load(fixture("dsl/load_int.eye")).should include(error: false)
+      sleep 0.5
+
+      p0 = subject.process_by_name 'p0'
+      p1 = subject.process_by_name 'p1'
+      p2 = subject.process_by_name 'p2'
+      gr1 = subject.group_by_name 'gr1'
+      gr_ = subject.group_by_name '__default__'
+
+      p0.schedule_history.states.should == [:monitor]
+      p1.schedule_history.states.should == [:monitor]
+      p2.schedule_history.states.should == [:monitor]
+      gr1.schedule_history.states.should == [:monitor]
+      gr_.schedule_history.states.should == [:monitor]
+
+      subject.load(fixture("dsl/load_int2.eye")).should include(error: false)
+      sleep 0.5
+
+      p1.alive?.should == false
+      p0.alive?.should == false
+
+      p01 = subject.process_by_name 'p0-1'
+      p4 = subject.process_by_name 'p4'
+      p5 = subject.process_by_name 'p5'
+      gr2 = subject.group_by_name 'gr2'
+
+      p2.schedule_history.states.should == [:monitor, :update_config]
+      gr1.schedule_history.states.should == [:monitor, :update_config]
+      gr_.schedule_history.states.should == [:monitor, :update_config]
+
+      p01.schedule_history.states.should == [:monitor]
+      p4.schedule_history.states.should == [:monitor]
+      p5.schedule_history.states.should == [:monitor]
+      gr2.schedule_history.states.should == [:monitor]
+    end
+  end
+
+  describe "load is exclusive" do
+    it "run double in time" do
+      t = Time.now
+      Eye::Control.async.command(:load, fixture("dsl/long_load.eye"))
+      Eye::Control.async.command(:load, fixture("dsl/long_load.eye"))
+      sleep 2.5      
+      Eye::Control.command(:info).should be_a(String) # actor should free here
+    end
+
+    it "load with subloads" do
+      silence_warnings{ 
+        Eye::Control.command(:load, fixture("dsl/subfolder2.eye"))
+      }
+      Eye::Control.command(:info).should be_a(String) # actor should free here
+    end
+  end
+
+end