auser-poolparty 0.1.2 → 0.2.2

data/spec/lib/poolparty/remoter_spec.rb

@@ -1,72 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../helpers/ec2_mock'
-
-class TestRemote
-  include Remoter
-  include Callbacks
-  attr_accessor :ip
-end
-describe "Remoter" do
-  before(:each) do
-    stub_option_load
-    
-    @instance = RemoteInstance.new
-    @master = Master.new    
-    
-    @remoter = TestRemote.new    
-    @remoter.stub!(:put).and_return "true"
-    # @tempfile = Tempfile.new("/tmp") do |f|
-    #   f << "hi"
-    # end
-    Application.stub!(:ec2_dir).and_return "/Users"
-    Application.stub!(:keypair).and_return "app"
-    Application.stub!(:username).and_return "root"
-    Application.stub!(:keypair_path).and_return "/Users/id_rsa-app"
-  end
-  it "should have an ssh method that corresponds to ssm with the keypair" do
-    RemoteInstance.ssh_string.should =~ /ssh -o StrictHostKeyChecking=no -l 'root' -i/
-  end
-  it "should an ssh array that just contains the ssh commands" do
-    RemoteInstance.ssh_array.should == ["-o StrictHostKeyChecking=no","-l 'root'","-i '/Users/id_rsa-app'"]
-  end
-  it "should have a list of ssh_tasks" do
-    @remoter.ssh_tasks.should == []
-  end
-  it "should have a list of scp_tasks" do
-    @remoter.scp_tasks.should == []
-  end
-  it "should reset the values to nil when calling reset" do
-    @remoter.target_hosts.should_not be_nil
-    @remoter.reset!
-    @hosts.should be_nil
-  end
-  describe "executing" do
-    it "should call set_hosts before it executes the tasks" do
-      @remoter.should_receive(:set_hosts).once
-      @remoter.execute_tasks {}
-    end
-    it "should not call set_hosts before it executes the task if it explicitly doesn't want it to" do
-      @remoter.should_not_receive(:set_hosts)
-      @remoter.execute_tasks(:dont_set_hosts => true) {}
-    end
-    
-    describe "ssh" do
-      before(:each) do
-        @arr = []
-        @arr << @a = proc{puts "hello"}
-        @arr << @b = proc{puts "world"}
-        @instance.stub!(:ip).and_return("127.0.0.1")
-      end
-      it "should run the tasks in an array with run_thread_list" do
-        @remoter.should_receive(:run_thread_list).once
-        @remoter.run_array_of_tasks(@arr)
-      end
-      
-      it "should be able to collect the list of the target hosts's ips" do
-        Master.should_receive(:new).and_return(@master)
-        @master.stub!(:nodes).and_return([@instance])
-        @remoter.target_hosts.should == %w(127.0.0.1)
-      end
-    end
-  end
-end

data/spec/lib/poolparty/remoting_spec.rb

@@ -1,148 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../helpers/ec2_mock'
-
-describe "Master remoting: " do
-  before(:each) do
-    stub_option_load
-    
-    Kernel.stub!(:system).and_return true
-    Application.stub!(:environment).and_return("test") # So it doesn't daemonize
-    Application.stub!(:minimum_instances).and_return(2)
-    Application.stub!(:maximum_instances).and_return(10)
-    Application.stub!(:polling_time).and_return(0.1)
-    Application.stub!(:verbose).and_return(false) # Turn off messaging
-    
-    @master = Master.new
-    @master.launch_new_instance!
-  end
-  describe "listing" do
-    before(:each) do
-      Application.stub!(:keypair).and_return("alist")
-      @a1={:instance_id => "i-a1", :ip => "127.0.0.1", :status => "running", :launching_time => 10.minutes.ago, :keypair => "alist"}
-      @a2={:instance_id => "i-a2", :ip => "127.0.0.3", :status => "running", :launching_time => 2.hours.ago, :keypair => "alist"}
-      @a3={:instance_id => "i-a3", :ip => "127.0.0.3", :status => "terminated", :launching_time => 2.hours.ago, :keypair => "alist"}
-      @a4={:instance_id => "i-a4", :ip => "127.0.0.4", :status => "pending", :launching_time => 2.hours.ago, :keypair => "alist"}
-      
-      @b1={:instance_id => "i-b1", :ip => "127.0.0.2", :status => "terminated", :launching_time => 55.minutes.ago, :keypair => "blist"}
-      @c1={:instance_id => "i-c1", :ip => "127.0.0.4", :status => "pending", :launching_time => 2.days.ago, :keypair => "clist"}
-      @master.stub!(:get_instances_description).and_return [@a1, @a2, @a3, @a4, @b1, @c1]
-    end
-    it "should pull out the list those instances with the keypair requested" do      
-      @master.list_of_instances.collect {|a| a[:instance_id]}.should == ["i-a1", "i-a2", "i-a3", "i-a4"]
-    end
-    it "should pull out the list with the blist keypair" do
-      Application.stub!(:keypair).and_return("blist")
-      @master.list_of_instances.collect {|a| a[:instance_id]}.should == ["i-b1"]
-    end
-    it "should be able to pull out the list_of_nonterminated_instances" do
-      @master.list_of_nonterminated_instances.should == [@a1, @a2, @a4]
-    end
-    it "should be able to pull the list of list_of_pending_instances" do
-      @master.list_of_pending_instances.should == [@a4]
-    end
-    it "should be able to pull the list of list_of_running_instances" do
-      @master.list_of_running_instances.should == [@a1, @a2]
-    end
-    it "should be able to get the number_of_pending_instances" do
-      @master.number_of_pending_instances.should == 1
-    end
-    it "should be able to grab the number_of_running_instances" do
-      @master.number_of_running_instances.should == 2
-    end
-    it "should be able to grab the entire list of instances" do
-      @master.list_of_all_instances.should == [@a1, @a2, @a3, @a4, @b1, @c1]
-    end
-    it "should be able to grab the entire list sorted by keypair" do
-      @master.cloud_keypairs.should == ["alist", "blist", "clist"]
-    end
-  end
-  describe "starting" do
-    before(:each) do
-      @master.start_cloud!
-      
-      @a1={:instance_id => "i-a1", :ip => "127.0.0.1", :status => "running", :launching_time => 10.minutes.ago, :keypair => "alist"}
-      @a2={:instance_id => "i-a2", :ip => "127.0.0.3", :status => "running", :launching_time => 2.hours.ago, :keypair => "alist"}
-      @a3={:instance_id => "i-a3", :ip => "127.0.0.3", :status => "terminated", :launching_time => 2.hours.ago, :keypair => "alist"}
-      @a4={:instance_id => "i-a4", :ip => "127.0.0.4", :status => "pending", :launching_time => 2.hours.ago, :keypair => "alist"}
-      
-      @b1={:instance_id => "i-b1", :ip => "127.0.0.2", :status => "terminated", :launching_time => 55.minutes.ago, :keypair => "blist"}
-      @c1={:instance_id => "i-c1", :ip => "127.0.0.4", :status => "pending", :launching_time => 2.days.ago, :keypair => "clist"}
-      @master.stub!(:get_instances_description).and_return [@a1, @a2, @a3, @a4, @b1, @c1]
-      
-      Application.stub!(:keypair).and_return "alist"
-    end
-    it "should start the cloud with instances" do
-      @master.list_of_instances.should_not be_empty
-    end
-    it "should start the cloud with running instances" do
-      @master.list_of_running_instances.should_not be_empty
-    end
-    it "should start with the minimum_instances running" do
-      wait 0.5 # Give the last one time to get to running
-      @master.list_of_running_instances.size.should == Application.minimum_instances
-    end
-  end
-  describe "maintaining" do
-    before(:each) do
-      Application.stub!(:keypair).and_return "alist"
-    end
-    it "should maintain the minimum_instances if one goes down" do
-      @master.start_cloud!
-      wait 0.2 # Give the two instances time to boot up
-      (Application.minimum_instances - @master.number_of_pending_and_running_instances).should == 0
-      
-      # Kill one off to test how it handles the response
-      @master.terminate_instance!(@master.list_of_running_instances[0][:instance_id])
-      (Application.minimum_instances - @master.number_of_pending_and_running_instances).should == 1
-      @master.launch_minimum_instances # Assume this runs in the bg process
-
-      (Application.minimum_instances - @master.number_of_pending_and_running_instances).should == 0
-      @master.number_of_pending_and_running_instances.should == Application.minimum_instances
-    end
-    it "should launch a new instance when the load gets too heavy set in the configs" do
-      @master.stub!(:expand?).and_return true
-      @master.start_cloud!
-      wait 0.5 # Give the two instances time to boot up
-      (Application.minimum_instances - @master.number_of_pending_and_running_instances).should == 0
-      @master.scale_cloud!
-      @master.nodes.size.should == Application.minimum_instances + 1
-    end
-    it "should terminate an instance when the load shows that it's too light" do
-      @master.stub!(:contract?).and_return true
-      @master.start_cloud!
-      @master.request_launch_new_instance
-      wait 0.5 # Give the two instances time to boot up
-      @master.number_of_pending_and_running_instances.should == Application.minimum_instances + 1
-      @master.scale_cloud!
-      @master.number_of_pending_and_running_instances.should == Application.minimum_instances
-    end
-  end
-  describe "configuring" do
-    before(:each) do
-      @instance = RemoteInstance.new
-      @instance.stub!(:ip).and_return "127.0.0.1"
-      @instance.stub!(:name).and_return "node0"
-      Master.stub!(:new).and_return @master
-      @master.stub!(:nodes).and_return [@instance]
-    end
-    it "should call configure on all of the nodes when calling reconfigure_running_instances" do
-      @master.nodes.each {|a| 
-        a.stub!(:status).and_return("running")
-        a.should_receive(:configure).and_return true 
-      }
-      @master.configure_cloud
-    end    
-    it "should call restart_with_monit on all of the nodes when calling restart_running_instances_services" do
-      @master.nodes.each {|a| a.should_receive(:restart_with_monit).and_return true }
-      @master.restart_running_instances_services
-    end
-    it "should be able to say there are no number_of_unconfigured_nodes left when all the nodes are configured" do
-      @master.nodes.each {|a| a.should_receive(:stack_installed?).and_return true }
-      @master.number_of_unconfigured_nodes.should == 0
-    end
-    it "should be able to say that there is an unconfigured node" do
-      @master.nodes[-1].should_receive(:stack_installed?).and_return false
-      @master.number_of_unconfigured_nodes.should_not == 0
-    end
-  end
-end

data/spec/lib/poolparty/scheduler_spec.rb

@@ -1,70 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-class TestSched  
-  include Scheduler
-end
-describe "Scheduler" do
-  before(:each) do
-    @test = TestSched.new
-  end
-  it "should create a ScheduleTasks" do
-    @test._tasker.class.should == ScheduleTasks
-  end
-  describe "run_thread_loop" do
-    before(:each) do
-      @klass = Class.new
-      @klass.stub!(:pop).once.and_return true
-      @block = Proc.new {@klass.pop}
-    end
-    it "should yield the block that it is given" do
-      @test.run_thread_list &@block
-    end
-    it "should run run_threads" do
-      @test.should_receive(:run_threads).and_return true
-      @test.run_thread_list &@block
-    end
-    it "should call run on the _tasker" do
-      @test._tasker.should_receive(:run).once.and_return true
-      @test.run_thread_list &@block
-    end
-    describe "ScheduleTasks class" do
-      before(:each) do
-        @stasks = ScheduleTasks.new
-        @test.stub!(:_tasker).and_return(@stasks)
-      end
-      it "should have its tasks listed as an empty array if there are no tasks added" do
-        @stasks.tasks.should == []
-      end
-      it "should have one task listed if it is added" do
-        @test.add_task {@klass.pop}        
-        @stasks.tasks.size.should == 1
-      end
-    end
-    describe "when running" do
-      before(:each) do
-        @test.add_task {@klass.pop}
-      end
-      it "should not run the tasks after adding them" do
-        @klass.should_not_receive(:pop)
-        @test.add_task {@klass.pop}
-      end
-      it "should run the tasks when run_thread_list" do
-        @klass.should_receive(:pop)
-        @test.run_thread_list
-      end
-      it "should use the ThreadPool" do
-        p = ThreadPool.new(10)
-        ThreadPool.should_receive(:new).with(10).and_return p
-        @test.run_thread_list
-      end
-      it "should process each of the tasks" do
-        @klass.should_receive(:pop)
-        @test.run_thread_list
-      end
-      it "should empty all the tasks after running them in the loop" do
-        @test.run_thread_list
-        @test._tasker.tasks.size.should == 0
-      end
-    end
-  end
-end

data/spec/monitors/cpu_monitor_spec.rb

@@ -1,39 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require "lib/poolparty/monitors/cpu"
-
-describe "monitors" do
-  describe "when included" do
-    before(:each) do
-      stub_option_load
-      @master = Master.new
-      @instance = RemoteInstance.new
-    end
-    it "should include them in the Monitors module" do
-      @master.methods.include?("cpu").should == true
-    end
-    it "should also include the new methods in the remote model" do
-      RemoteInstance.new.methods.include?("cpu").should == true
-    end
-    describe "master" do
-      before(:each) do
-        @master.stub!(:list_of_nonterminated_instances).and_return(
-        [{:instance_id => "i-abcdde1"}]
-        )
-      end
-      it "should try to collect the cpu for the entire set of remote instances when calling cpu" do
-        @master.nodes.should_receive(:inject).once.with(0).and_return 0.0
-        @master.cpu
-      end
-    end
-    describe "remote instance" do
-      it "should try to ssh into the remote instance" do
-        @instance.should_receive(:run).once.with("uptime")
-        @instance.cpu
-      end
-      it "should be able to find the exact amount of time the processor has been up" do
-        @instance.stub!(:run).once.with("uptime").and_return("18:55:31 up 5 min,  1 user,  load average: 0.32, 0.03, 0.00")
-        @instance.cpu.should == 0.32
-      end
-    end
-  end
-end

data/spec/monitors/memory_spec.rb

@@ -1,51 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require "lib/poolparty/monitors/memory"
-
-describe "monitors" do
-  describe "when included" do
-    before(:each) do      
-      stub_option_load
-      @master = Master.new
-      @instance = RemoteInstance.new
-    end
-    it "should include them in the Monitors module" do
-      @master.methods.include?("memory").should == true
-    end
-    it "should also include the new methods in the remote model" do
-      @instance.methods.include?("memory").should == true
-    end
-    describe "master" do
-      before(:each) do
-        @master.stub!(:list_of_nonterminated_instances).and_return(
-        [{:instance_id => "i-abcdde1"}]
-        )
-      end
-      it "should try to collect the cpu for the entire set of remote instances when calling cpu" do
-        @master.nodes.should_receive(:inject).once.and_return 0.0
-        @master.memory
-      end
-    end
-    describe "remote instance" do
-      it "should try to run into the remote instance" do
-        @instance.should_receive(:run).once.with("free -m | grep -i mem")
-        @instance.memory
-      end
-      it "should be able to find the exact amount of time the processor has been up" do
-        @instance.stub!(:run).once.with("free -m | grep -i mem").and_return("Mem:          1700         546       1644          0          2         18")
-        @instance.memory.round_to(2).should == 0.32
-      end
-    end
-    # it "should web monitor should be able to extract the amount of the requests it can handle" do
-    #   str = "Request rate: 1.5 req/s (649.9 ms/req)"
-    #   # Monitors::Web.monitor_from_string(str).should == 1.5
-    # end
-    # it "should be able to monitor the percentage of memory available on the server" do
-    #   str = "Mem:          1700         56       1644          0          2         18"
-    #   # Monitors::Memory.monitor_from_string(str).to_s.should =~ /0.032/
-    # end
-    # it "should be able to show the load on the cpu available on the server" do
-    #   str = "18:55:31 up 5 min,  1 user,  load average: 0.32, 0.03, 0.00"
-    #   # Monitors::Cpu.monitor_from_string(str).should == 0.32
-    # end
-  end
-end

data/spec/monitors/misc_monitor_spec.rb

@@ -1,51 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module Database
-  module Master
-    def db
-      nodes.inject(0) {|i,inst| i * inst.db} / nodes.size
-    end
-  end
-  module Remote
-    def db
-      5.0
-    end
-  end
-end
-
-PoolParty.register_monitor Database
-
-describe "monitors (random, to spec the inclusion)" do
-  describe "when included" do
-    before(:each) do      
-      stub_option_load
-      @master = Master.new
-      @instance = RemoteInstance.new
-    end
-    it "should include them in the Monitors module" do
-      @master.methods.include?("db").should == true
-    end
-    it "should also include the new methods in the remote model" do
-      @instance.methods.include?("db").should == true
-    end
-    describe "master" do
-      before(:each) do
-        @master.stub!(:list_of_nonterminated_instances).and_return(
-        [{:instance_id => "i-abcdde1"}]
-        )
-      end
-      it "should try to collect the cpu for the entire set of remote instances when calling cpu" do
-        @master.nodes.should_receive(:inject).once.and_return 5.0
-        @master.db.should == 5.0
-      end
-    end
-    describe "remote instance" do
-      it "should try to run into the remote instance" do
-        @instance.db.should == 5.0
-      end
-      it "should be able to find the exact amount of time the processor has been up" do
-        @instance.db.round_to(2).should == 5.0
-      end
-    end
-  end
-end

data/spec/monitors/web_spec.rb

@@ -1,40 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require "lib/poolparty/monitors/web"
-
-describe "monitors" do
-  describe "when included" do
-    before(:each) do      
-      stub_option_load
-      Application.stub!(:client_port).and_return 8001
-      @master = Master.new
-      @instance = RemoteInstance.new
-    end
-    it "should include them in the Monitors module" do
-      @master.methods.include?("web").should == true
-    end
-    it "should also include the new methods in the remote model" do
-      @instance.methods.include?("web").should == true
-    end
-    describe "master" do
-      before(:each) do
-        @master.stub!(:list_of_nonterminated_instances).and_return(
-        [{:instance_id => "i-abcdde1"}]
-        )
-      end
-      it "should try to collect the cpu for the entire set of remote instances when calling cpu" do
-        @master.nodes.should_receive(:inject).once.and_return 0.0
-        @master.web
-      end
-    end
-    describe "remote instance" do
-      it "should try to run into the remote instance" do
-        @instance.should_receive(:run).once.with("httperf --server localhost --port #{Application.client_port} --num-conn 3 --timeout 5 | grep 'Request rate'")
-        @instance.web
-      end
-      it "should be able to find the exact amount of time the processor has been up" do
-        @instance.stub!(:run).once.and_return("Request rate: 1.5 req/s (649.9 ms/req)")
-        @instance.web.round_to(2).should == 1.5
-      end
-    end
-  end
-end