poolparty 0.0.4 → 0.2.6

data/spec/helpers/ec2_mock.rb

@@ -1,56 +0,0 @@
-module PoolParty
-  module EC2Mock
-    def launch_new_instance!
-      letter = ("a".."z").to_a[instances.size] # For unique instance_ids
-      h = {:instance_id => "i-58ba56#{letter}", :ip => "ip-127-0-0-1.aws.amazonaws.com", :status => "pending", :launching_time => Time.now }
-      instances << h      
-      Thread.new {wait 0.1;h[:status] = "running"} # Simulate the startup time
-      return h
-    end
-    # Shutdown the instance by instance_id
-    def terminate_instance!(instance_id)
-      instances.select {|a| a[:instance_id] == instance_id}[0][:status] = "terminating"
-    end
-    # Instance description
-    def describe_instance(id)
-      item = instances.select {|a| a[:instance_id] == id}[0]
-      EC2ResponseObject.get_hash_from_response(item)
-    end
-    # Get instance by id
-    def get_instance_by_id(id)
-      get_instances_description.select {|a| a.instance_id == id}[0] rescue nil
-    end
-    # Get the s3 description for the response in a hash format
-    def get_instances_description
-      instances
-    end
-    # Fake the ec2 connection
-    def ec2
-      @ec2 ||= EC2::Base.new(:access_key_id => "not a key", :secret_access_key => "not a key")
-    end
-    # Some basic instances, not totally necessary
-    def instances
-      @instances ||= []
-    end
-  end
-  class EC2ResponseObject
-    def self.get_descriptions(resp)
-      rs = resp.DescribeInstancesResponse.reservationSet.item
-      rs = rs.respond_to?(:instancesSet) ? rs.instancesSet : rs
-      out = begin
-        rs.reject {|a| a.empty? }.collect {|r| EC2ResponseObject.get_hash_from_response(r.instancesSet.item)}.reject {|a| a.nil?  }
-      rescue Exception => e
-        begin
-          # Really weird bug with amazon's ec2 gem
-          rs.reject {|a| a.empty? }.collect {|r| EC2ResponseObject.get_hash_from_response(r)}.reject {|a| a.nil?  }
-        rescue Exception => e
-          []
-        end                
-      end
-      out
-    end
-    def self.get_hash_from_response(resp)
-      {:instance_id => resp.instanceId, :ip => resp.dnsName, :status => resp.instanceState.name, :launching_time => resp.launchTime} rescue nil
-    end
-  end
-end

data/spec/helpers/remote_instance_mock.rb

@@ -1,11 +0,0 @@
-module PoolParty
-  module RemoteInstanceMock
-    def scp(src="", dest="")
-      true
-    end
-    # Ssh into the instance or run a command, if the cmd is set
-    def ssh(cmd="")
-      true
-    end
-  end
-end

data/spec/kernel_spec.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Kernel extensions" do
-  before(:each) do
-    @host = Master.new
-  end
-  it "should eval the string into time" do
-    @host.should_receive(:sleep).once.and_return true
-    @host.wait "10.seconds"
-  end
-end

data/spec/master_spec.rb

@@ -1,147 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Master" do
-  before(:each) do
-    Application.options.stub!(:contract_when).and_return("web_requests > 30.0\n cpu_usage < 0.10")
-    Application.options.stub!(:expand_when).and_return("web_requests < 3.0\n cpu_usage > 0.80")
-    @master = Master.new
-  end  
-  it "should launch the first instances and set the first as the master and the rest as slaves" do
-    Application.stub!(:minimum_instances).and_return(1)
-    Application.stub!(:verbose).and_return(false) # Hide messages
-    Master.stub!(:new).and_return(@master)
-    
-    @master.stub!(:number_of_running_instances).and_return(0);
-    @master.stub!(:number_of_pending_instances).and_return(0);
-    
-    @master.should_receive(:launch_new_instance!).and_return(
-    {:instance_id => "i-5849ba", :ip => "ip-127-0-0-1.aws.amazon.com", :status => "running"})
-    @master.stub!(:list_of_nonterminated_instances).and_return(
-    [{:instance_id => "i-5849ba", :ip => "ip-127-0-0-1.aws.amazon.com", :status => "running"}])
-    @master.start_cloud!
-    @master.nodes.first.instance_id.should == "i-5849ba"
-  end
-  describe "with stubbed instances" do
-    before(:each) do
-      @master.stub!(:list_of_nonterminated_instances).and_return([
-          {:instance_id => "i-5849ba", :ip => "ip-127-0-0-1.aws.amazon.com", :status => "running"},
-          {:instance_id => "i-5849bb", :ip => "ip-127-0-0-2.aws.amazon.com", :status => "running"},
-          {:instance_id => "i-5849bc", :ip => "ip-127-0-0-3.aws.amazon.com", :status => "pending"}
-        ])
-      Kernel.stub!(:exec).and_return true
-    end
-    
-    it "should be able to go through the instances and assign them numbers" do
-      i = 0
-      @master.nodes.each do |node|
-        node.number.should == i
-        i += 1
-      end
-    end
-    it "should be able to say that the master is the master" do
-      @master.nodes.first.master?.should == true      
-    end
-    it "should be able to say that the slave is not a master" do
-      @master.nodes[1].master?.should == false
-    end
-    it "should be able to get a specific node in the nodes from the master" do
-      @master.get_node(2).instance_id.should == "i-5849bc"
-    end
-    it "should be able to build a hosts file" do
-      open(@master.build_hosts_file.path).read.should == "node0\tip-127-0-0-1.aws.amazon.com\nnode1\tip-127-0-0-2.aws.amazon.com\nnode2\tip-127-0-0-3.aws.amazon.com"
-    end
-    it "should be able to build a hosts file for a specific instance" do
-      open(@master.build_hosts_file_for(@master.nodes.first).path).read.should =~ "node0\t127.0.0.1"
-    end
-    it "should be able to build a haproxy file" do
-      open(@master.build_haproxy_file.path).read.should =~ "server node0 ip-127-0-0-1.aws.amazon.com:#{Application.client_port}"
-    end
-    it "should be able to reconfigure the instances (working on two files a piece)" do
-      @master.nodes.each {|a| a.should_receive(:configure).and_return true if a.status =~ /running/}
-      @master.reconfigure_running_instances
-    end
-    it "should be able to restart the 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 build a heartbeat auth file" do
-      open(@master.build_heartbeat_authkeys_file).read.should =~ /1 md5/
-    end
-    describe "configuring" do
-      before(:each) do
-        Master.stub!(:new).and_return(@master)
-      end
-      it "should be able to build a heartbeat resources file for the specific node" do
-        open(Master.build_heartbeat_resources_file_for(@master.nodes.first)).read.should =~ /node0\tip-127/
-      end
-      it "should be able to build a heartbeat config file" do
-        open(Master.build_heartbeat_config_file_for(@master.nodes.first)).read.should =~ /\nnode node0\nnode node1/
-      end      
-      it "should be able to say if heartbeat is necessary with more than 1 server or not" do      
-        Master.requires_heartbeat?.should == true
-      end
-      it "should be able to say that heartbeat is not necessary if there is 1 server" do
-        @master.stub!(:list_of_nonterminated_instances).and_return([
-            {:instance_id => "i-5849ba", :ip => "ip-127-0-0-1.aws.amazon.com", :status => "running"}
-          ])
-        Master.requires_heartbeat?.should == false
-      end
-      it "should only install the stack on nodes that don't have it marked locally as installed" do
-        @master.nodes.each {|i| i.should_receive(:stack_installed?).and_return(true)}
-        @master.should_not_receive(:reconfigure_running_instances)
-        @master.reconfigure_cloud_when_necessary
-      end
-      it "should install the stack on all the nodes (because it needs reconfiguring) if there is any node that needs the stack" do
-        @master.nodes.first.should_receive(:stack_installed?).and_return(false)
-        @master.should_receive(:reconfigure_running_instances).once.and_return(true)
-        @master.reconfigure_cloud_when_necessary
-      end
-    end
-    describe "displaying" do
-      it "should be able to list the cloud instances" do
-        @master.list.should =~ /CLOUD \(/
-      end
-    end
-    describe "monitoring" do
-      it "should start the monitor when calling start_monitor!" do
-        @master.should_receive(:run_thread_loop).and_return(Proc.new {})
-        @master.start_monitor!
-      end
-      it "should request to launch a new instance" do
-        @master.should_receive(:add_instance_if_load_is_high).and_return(true)
-        @master.add_instance_if_load_is_high
-      end
-      it "should request to terminate a non-master instance if the load" do
-        @master.should_receive(:contract?).and_return(true)
-        @master.should_receive(:request_termination_of_instance).and_return(true)
-        @master.terminate_instance_if_load_is_low
-      end
-    end
-    describe "expanding and contracting" do      
-      it "should be able to say that it should not contract" do            
-        @master.stub!(:web_requests).and_return(10.2)
-        @master.stub!(:cpu_usage).and_return(0.32)
-        
-        @master.contract?.should == false
-      end
-      it "should be able to say that it should contract" do      
-        @master.stub!(:web_requests).and_return(30.2)
-        @master.stub!(:cpu_usage).and_return(0.05)
-
-        @master.contract?.should == true
-      end
-      it "should be able to say that it should not expand if it shouldn't expand" do
-        @master.stub!(:web_requests).and_return(30.2)
-        @master.stub!(:cpu_usage).and_return(0.92)
-
-        @master.expand?.should == false
-      end
-      it "should be able to say that it should expand if it should expand" do
-        @master.stub!(:web_requests).and_return(1.2)
-        @master.stub!(:cpu_usage).and_return(0.92)
-
-        @master.expand?.should == true
-      end
-    end
-  end
-end

data/spec/monitor_spec.rb

@@ -1,16 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "monitors" do
-  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

data/spec/optioner_spec.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Optioner with options" do
-  it "should be able to pull out the lonely arguments without any switches" do
-    Optioner.parse("hello".split(" ")).should == ["hello"]
-  end
-  it "should be able to pull out the lonely arguments with switches" do
-    Optioner.parse("-s 30.seconds -m hello world".split(" ")).should == ["world"]
-  end
-  it "should be able to pull out start from the the string" do
-    Optioner.parse("-c 'config/config.yml' -A 'Who' -S 'DarkwingDuck' list".split(" ")).should == ["list"]
-  end
-  it "should be able to pull out the lonely arguments with optional argument switches" do
-    Optioner.parse("-s 30 -q -n start".split(" "), %w(-q -n)).should == ["start"]
-  end
-  it "should pull out the lonely arguments if none are there" do
-    Optioner.parse("-s 30 -q".split(" ")).should == []
-  end
-  it "should pull out empty array if there are no lonely arguments" do
-    Optioner.parse("-s 30".split(" ")).should == []
-  end
-end

data/spec/poolparty_spec.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Application options" do
-  it "should parse and use a config file if it is given for the options" do
-    YAML.should_receive(:load).and_return({:config_file => "config/config.yml"})
-    Application.make_options(:config_file => "config/config.yml")
-  end
-end

data/spec/remote_instance_spec.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "remote instance" do
-  before(:each) do
-    @instance = RemoteInstance.new({:ip => "127.0.0.1"})
-    @instance.stub!(:ssh).and_return "true"
-    @instance.stub!(:scp).and_return "true"
-  end
-  
-  describe "in general" do
-    it "should set the ip upon creation" do
-      @instance.ip.should == "127.0.0.1"
-    end
-    it "should be able to tell if it is the master or not" do
-      @instance.master?.should == true
-    end
-    it "should be able to build a list of the heartbeat nodes" do
-      @instance.node_entry.should =~ /node/
-    end
-    it "should call configure after it calls install_stack" do
-      @instance.should_receive(:configure).once.and_return(true)
-      @instance.install_stack
-    end
-    it "should call restart_with_monit after it calls configure" do
-      @instance.should_receive(:restart_with_monit).once.and_return(true)
-      @instance.configure
-    end
-  end
-end

data/spec/remoting_spec.rb

@@ -1,75 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-# RUN THESE ONE AT A TIME
-module PoolParty
-  class Master;include EC2Mock;end
-  class RemoteInstance; include RemoteInstanceMock;end
-end
-
-describe "Master remoting: " do
-  before(:each) do
-    Application.stub!(:environment).and_return("test") # So it daemonizes
-    Application.stub!(:minimum_instances).and_return(2)
-    Application.stub!(:maximum_instances).and_return(10)
-    Application.stub!(:polling_time).and_return(0.3)
-    Application.stub!(:verbose).and_return(false) # Turn off messaging
-    
-    @master = Master.new
-  end
-  describe "starting" do
-    before(:each) do
-      @master.start_cloud!
-    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
-    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.2 # Give the two instances time to boot up
-      (Application.minimum_instances - @master.number_of_pending_and_running_instances).should == 0
-      @master.add_instance_if_load_is_high
-      @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.terminate_instance_if_load_is_low
-      @master.number_of_pending_and_running_instances.should == Application.minimum_instances
-    end
-  end
-  describe "configuring" do
-    it "should call configure on all of the nodes when calling reconfigure_running_instances" do
-      @master.nodes.each {|a| a.should_receive(:configure).and_return true }
-      @master.reconfigure_running_instances
-    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
-  end
-end

data/spec/spec_helper.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(__FILE__), *%w[.. lib pool_party])
-
-%w(test/spec).each do |library|
-  begin
-    require library
-  rescue
-    STDERR.puts "== Cannot run test without #{library}"
-  end
-end
-
-Dir["#{File.dirname(__FILE__)}/helpers/**"].each {|a| require a}
-
-include PoolParty
-extend PoolParty
-
-Application.verbose = false
-
-def wait_launch(time=5)
-  pid = fork {yield}
-  wait time
-  Process.kill("INT", pid)
-  Process.wait(pid, 0)
-end
-
-module Test::Unit::AssertDifference
-  def assert_difference(object, method = nil, difference = 1)
-    initial_value = object.send(method)
-    yield
-    assert_equal initial_value + difference, object.send(method), "#{object}##{method}"
-  end
-
-  def assert_no_difference(object, method, &block)
-    assert_difference object, method, 0, &block
-  end
-end
-
-Test::Spec::Should.send(:include, Test::Unit::AssertDifference)
-Test::Spec::ShouldNot.send(:include, Test::Unit::AssertDifference)

data/spec/string_spec.rb

@@ -1,28 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "String" do
-  before(:each) do
-    @string = "string"
-    @string.stub!(:bucket_objects).and_return([])
-  end
-  # Dumb test
-  it "should be able to call bucket_objects on itself" do
-    @string.should_receive(:bucket_objects)
-    @string.bucket_objects
-  end
-  describe "with config replacements" do
-    it "should replace those syms in the string" do
-      ("new :port" ^ {:port => 100}).should == "new 100"
-    end
-    it "should be able to detect vars" do
-      @string=<<-EOC
-listen web_proxy 127.0.0.1::client_port
-\tserver web1 127.0.0.1::port weight 1 minconn 3 maxconn 6 check inter 30000
-      EOC
-      (@string ^ {:client_port => 3000, :port => 3001}).should ==<<-EOO
-listen web_proxy 127.0.0.1:3000
-\tserver web1 127.0.0.1:3001 weight 1 minconn 3 maxconn 6 check inter 30000
-      EOO
-    end
-  end
-end