ant_hill 0.3.1

data/lib/ant_hill/version.rb

@@ -0,0 +1,4 @@
+module AntHill
+  # Version of gem
+  VERSION = "0.3.1"
+end

data/lib/tasks/ant_hill.rake

@@ -0,0 +1,48 @@
+require 'ant_hill'
+
+namespace :ant_hill do
+  task :add_colony do
+    host = ENV['drb_host'] || 'localhost'
+    AntHill::Queen.create_colony ARGV[1..-1], host
+  end
+
+  task :kill_colony do
+    host = ENV['drb_host'] || 'localhost'
+    AntHill::Queen.kill_colony ARGV[1..-1], host
+  end
+
+  task :monitor do
+    queen = AntHill::Queen.drb_queen(host)
+    while true
+      sleep 2
+      print "\e[2J\e[f"
+      puts "Creep size: #{queen.creeps.size}"
+      puts "Ants left: #{queen.size}"
+      queen.creeps.each{|creep|
+        puts creep.to_s
+      }
+    end
+  end
+
+  task :execute_each do
+    threads = []
+    AntHill::Queen.creeps(host).each{|creep|
+      threads << Thread.new do
+         creep.exec!(ENV['command'])
+      end
+    }
+    threads.each{ |t| t.join}
+  end
+
+  task :suspend_queen do
+    AntHill::Queen.drb_queen(host).suspend
+  end
+
+  task :release_queen do
+    AntHill::Queen.drb_queen(host).release
+  end
+
+  def host
+    ENV['drb_host'] || 'localhost'
+  end
+end

data/spec/ant_hill/ant_colony_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module AntHill
+  describe AntColony do
+    let(:params){ {"type" => "type", "a" => 1, "b" => 2 } }
+    let(:colony){ AntColony.new(params) }
+    
+    before :each do
+      config = double("config")
+      config.stub(:creep_modifier_class){|type| "Creep modifier for #{type}" }
+      config.stub(:log_level){ :log_level }
+      config.stub(:log_dir){ log_dir }
+      config.stub(:init_time){ Time.now}
+      Configuration.stub(:config){config}
+      
+      logger = double("logger")
+      Log.stub(:logger_for){logger}        
+    end
+
+    context "#initialize" do
+      it "should store params" do
+        colony.params.should eql(params)
+      end
+    end
+
+    context "#type" do
+      it "should return type from params" do
+        colony.type.should eql("type")
+      end
+    end
+
+    context "#creep_modifier_class" do
+      it "should return creep modifier class for type" do
+        Configuration.config.should_receive(:creep_modifier_class).with("type").and_return("Creep modifier for type")
+        colony.creep_modifier_class.should eql("Creep modifier for type")
+      end
+
+      it "should log error if no such type defined" do
+        test_params = params
+        test_params['type']="wrong_type"
+
+        colony = AntColony.new(params)
+        Configuration.config.should_receive(:creep_modifier_class).with("wrong_type").and_return(nil)
+        Log.logger_for.should_receive(:error).with("Colony will die without creep modifier ;(")
+        colony.creep_modifier_class.should be_nil
+      end
+    end
+
+    context "#spoiled?" do
+      it "should be spoiled if no creep modifier class was set" do
+        test_params = params
+        test_params['type']="wrong_type"
+        colony = AntColony.new(params)
+        colony.spoiled?.should be_true
+      end
+    end
+
+    context "#get_ants" do
+      it "should add self params to all ants " do
+        colony.stub(:search_ants){ [{:param1 => 1, :param2 => 2},{ :param1 => 3, :param2 => 2}] }
+        ants = colony.get_ants
+        ants.should_not be_empty
+        ants.each{|ant|
+          ant.params['type'].should eql('type')
+          ant.params['a'].should eql(1)
+          ant.params['b'].should eql(2)
+          ant.params[:param2].should eql(2)
+        }
+        ants[0].params[:param1].should eql(1)
+        ants[1].params[:param1].should eql(3)
+      end
+
+      it "should call after_search" do
+        colony.stub(:search_ants){ [{:param1 => 1, :param2 => 2},{ :param1 => 3, :param2 => 2}] }
+        colony.should_receive(:after_search)
+        colony.get_ants
+      end
+
+      it "should log error if something's happened" do
+        colony.stub(:search_ants){ raise }
+        Log.logger_for.should_receive(:error).with(/Error while processing search ants for colony/)
+        ants = colony.get_ants
+      end
+    end
+
+    context "#is_it_me?" do
+      it "should return true if all params matches" do
+        colony.is_it_me?({"type"=> "type", "a" => 1}).should be_true
+      end
+      it "should return false if at least one param doesn't match" do
+        colony.is_it_me?({"type"=> "type", "a" => 2}).should be_false
+      end
+    end
+
+    context "#not_finished" do
+      it "should return not finished ants" do
+        ant1 = double("ant1")
+        ant2 = double("ant2")
+        ant3 = double("ant3")
+        ant4 = double("ant4")
+        ant1.stub(:finished?){true}
+        ant2.stub(:finished?){false}
+        ant3.stub(:finished?){true}
+        ant4.stub(:finished?){true}
+        colony.stub(:ants){ [ant1, ant2, ant3, ant4] }
+        colony.not_finished.should eql([ant1, ant3, ant4])
+      end
+
+    end
+    context "#type" do
+      it "should return type from params" do
+        colony.params['type'].should eql("type")
+      end
+    end
+
+
+  end
+end

data/spec/ant_hill/ant_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module AntHill
+  describe Ant do
+    before :each do
+      config = double("config")
+      config.stub(:creep_modifier_class){|type| "Creep modifier for #{type}" }
+      config.stub(:log_level){ :log_level }
+      config.stub(:log_dir){ log_dir }
+      config.stub(:init_time){ Time.at(0)}
+      Configuration.stub(:config){config}
+      
+      logger = double("logger")
+      Log.stub(:logger_for){logger}        
+    end
+
+    let(:ant_colony){ 
+      ac = double("ant_colony")
+      ac.stub(:type){ "type" }
+      ac.stub(:params){ {"type" => "type", "a" => 1, "b" => 2} }
+      cmc = double(:creep_modifier_class)
+      cm = double(:creep_modifier)
+      cmc.stub(:change_time_for_param){|param|
+        case param
+          when 'a' then 1
+          when 'b' then 2
+          else
+            0
+        end
+
+      }
+      cmc.stub(:new){ cm}
+      ac.stub(:creep_modifier_class){cmc}
+      ac.stub(:change_time_for_param){|param|
+        case param
+          when 'a' then 1
+          when 'b' then 2
+          else
+            0
+        end
+
+      }
+      ac
+    }
+
+    let(:ant){Ant.new( { "param1" => "params", "param2" => "param2"}, ant_colony )}
+
+    context "#initialize" do
+      it "should have colony" do
+        ant.colony.should eql(ant_colony)
+      end
+      it "should merge colony and self params" do
+        ant.params.should eql({ "type" => "type", "a" => 1, "b" => 2, "param1" => "params", "param2" => "param2" })
+      end
+      it "should have status not_started" do
+        ant.status.should eql(:not_started)
+      end
+    end
+
+    context "#to_s" do
+      it "should return string of params" do
+        ant.to_s.should eql(ant.params.inspect.to_s)
+      end
+    end
+
+    context "#change_status" do
+      it "should set status" do
+        ant.change_status(:started)
+        ant.status.should eql(:started)
+      end
+    end
+
+    context "#priority" do
+      it "should have higher priority for matches params" do
+        ant.priority({}).should < ant.priority({"a" => 1})
+        ant.priority({"a" => 1}).should < ant.priority({"a" => 1, "b" => 2})
+      end
+
+      it "should increase priority on sum values defined for param in change_time_for_param method" do
+        ant.priority({ "a" => 1 }).should be_within(0.0001).of( ant.priority({"a" => 0}) + 1 )
+        ant.priority({ "b" => 2 }).should be_within(0.0001).of( ant.priority({"b" => 0}) + 2 )
+
+      end
+      it "should return same value for same params " do
+        ant.priority({ "b" => 2 }).should be_within(0.0001).of( ant.priority({"b" => 2}) )
+      end
+
+    end
+
+    context "#finished?" do
+      it "should return false if ant status is finished" do
+        ant.stub(:status){:in_progress}
+        ant.finished?.should be_false
+      end
+      it "should return true if ant status is finished" do
+        ant.stub(:status){:finished}
+        ant.finished?.should be_true
+      end
+    end
+  end
+end

data/spec/ant_hill/configuration_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+module AntHill
+  describe Configuration do
+
+    let(:hash){
+        {
+          'basedir' => "a",
+          'lib_path' => 'b',
+          'sleep_interval' => 1,
+          'log_dir' => 'some_dir',
+          'log_level' => ':error',
+          'types' => {
+            'a' => {
+              'ant_colony_class' => 'String',
+              'creep_modifier_class' => 'Object'
+            },
+            'b' => {
+              'ant_colony_class' => 'Hash',
+              'creep_modifier_class' => 'String'
+            },
+            'c' => {
+              'ant_colony_class' => 'SomeClass',
+              'creep_modifier_class' => 'SomeOtherClass'
+            }
+          },
+          'default_type' => 'a',
+          'log_path' => 'log_path',
+          'creeps' => [
+            { 'name' => 1, 'host' => 'host', 'login' => 'login', 'password' => 'password'},
+            { 'name' => 2, 'host' => 'host2', 'login' => 'login2', 'password' => 'password2'}
+          ] 
+
+        }
+    }
+    before(:each) do
+      YAML.stub(:load_file) {|filename| hash }
+      Time.stub(:now) { Time.at(0) }
+      File.stub(:join) { 'rubygems'}
+      logger = double("logger")
+      Log.stub(:logger_for){logger}        
+    end
+
+    let(:config) { Configuration.new }
+    
+    let(:config_parsed){
+      c = Configuration.new
+      c.parse_yaml("config.yml")
+      c
+    }
+
+    context "#initialize" do
+      it "should set init_time" do
+        config.init_time == Time.at(0)
+      end
+    end
+
+    context "#parse_yaml" do
+      it "should fail if file not exists" do
+        STDERR.stub(:puts)
+        STDERR.should_receive(:puts).with(/Couldn't find config file/)
+        YAML.stub(:load_file){raise}
+        lambda{ config.parse_yaml("config.yml") }.should raise_error(SystemExit)
+      end
+
+      it "should load configuration" do
+        config.parse_yaml("config.yml")
+        config.instance_variable_get("@configuration").should_not eql({})
+      end
+    end
+
+    context "#require_libs" do
+      it "should require file base_dir+libpath" do
+        config_parsed.stub(:require){nil}
+        config_parsed.should_receive(:require).with("rubygems")
+        config_parsed.require_libs
+      end
+      it "should require file base_dir+libpath" do
+        config_parsed.stub(:require){ raise LoadError }
+        config_parsed.should_receive(:require).with("rubygems")
+        STDERR.should_receive(:puts).with(/Configuration file is invalid! No such file exists rubygems/)
+        config_parsed.require_libs
+      end
+    end
+
+    context "#validate" do
+
+      context "with valid config" do
+        it "should not exit if config is valid" do
+          lambda{config_parsed.validate}.should_not raise_error(SystemExit)
+        end
+      end
+      context "with invalid config" do
+        before(:each) do
+          STDERR.stub(:puts)
+        end
+        %w{ basedir lib_path types creeps log_dir log_level }.each do |key|
+          it "should log error and exit if #{key} unset" do
+            new_hash = hash.clone
+            new_hash.delete(key)
+            YAML.stub(:load_file){|filename| new_hash }
+            c = Configuration.new
+            c.parse_yaml("config.yml")
+            STDERR.should_receive(:puts).with(/Configuration file is invalid! Pls. define .* keys in it/)
+            lambda{c.validate}.should raise_error(SystemExit)
+          end
+        end
+
+        %w{ types creeps }.each do |key|
+          it "should log error and exit #{key} has no children" do
+            new_hash = hash.clone
+            new_hash[key] = []
+            YAML.stub(:load_file){|filename| new_hash }
+            c = Configuration.new
+            c.parse_yaml("config.yml")
+            STDERR.should_receive(:puts).with(/Configuration file is invalid! Pls. define at least one .* in #{key} section/)
+            lambda{c.validate}.should raise_error(SystemExit)
+          end
+        end
+      end
+    end
+
+    context "#creep_modifier_class" do
+      it "should return creep_modifier_class from config if type specified" do
+        config_parsed.creep_modifier_class('b').should eql(String)
+      end
+      it "should return creep_modifier_class from config for default type if not type specified" do
+        config_parsed.creep_modifier_class.should eql(Object)
+      end
+    end
+    
+    context "#ant_colony_class" do
+      it "should return creep_modifier_class from config if type specified" do
+        config_parsed.ant_colony_class('b').should eql(Hash)
+      end
+      it "should return creep_modifier_class from config for default type if not type specified" do
+        config_parsed.ant_colony_class.should eql(String)
+      end
+    end
+
+    context "#get_class_by_type_and_object" do
+      it "should log error if no class name defiend for given type and object" do
+        Log.logger_for.should_receive(:error).with(/No class configuration defined for object and type a/)
+        Log.logger_for.should_receive(:error).with(/No class configuration defined for String and type d/)
+        config_parsed.get_class_by_type_and_object('a', 'object')
+        config_parsed.get_class_by_type_and_object('d', 'String')
+      end
+      it "should log error if no specified class defiend" do
+        Log.logger_for.should_receive(:error).with("No such class defined: SomeClass")
+        config_parsed.get_class_by_type_and_object('c', 'ant_colony_class')
+      end
+    end
+
+    context "#[]" do
+      it "should access to configuration with [] method" do
+        config_parsed['default_type'].should eql('a')
+        config_parsed['default_type'].should eql('a')
+      end
+    end
+    
+    context "#method_missing" do
+      it "should return default_type from config" do
+        config_parsed.default_type.should eql("a")
+      end
+    end
+
+    context "Configuration#config" do
+      let(:config_double){
+        config_double = double("config")
+        config_double.stub(:parse_yaml){|file| }
+        config_double.stub(:validate)
+        config_double.stub(:require_libs)
+        config_double
+      }
+      before :each do
+        Configuration.method(:remove_class_variable).call(:@@config) if Configuration.class_variable_defined?(:@@config)
+      end
+      it "should return same object every time" do
+        Configuration.stub(:new){config_double}
+        config_double.should_receive(:parse_yaml)
+        config_double.should_receive(:validate)
+        config_double.should_receive(:require_libs)
+        Configuration.config.should be_equal(Configuration.config)
+      end
+      it "should use passed filename for parsing" do
+        Configuration.stub(:new){ config_double }
+        config_double.should_receive(:parse_yaml).with("filename.yml")
+        config_double.should_receive(:require_libs)
+        config_double.should_receive(:validate)
+        Configuration.config("filename.yml")
+      end
+      it "should use ARGV[0] as filename for parsing" do
+        Configuration.stub(:new){ config_double }
+        ARGV[0]='filename.yml'
+        config_double.should_receive(:parse_yaml).with("filename.yml")
+        config_double.should_receive(:require_libs)
+        config_double.should_receive(:validate)
+        Configuration.config
+      end
+    end
+  end
+end