auser-poolparty 0.0.8

data/spec/remote_instance_spec.rb

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class RemoteInstance
+  def scp(src="", dest="", opts={})
+    "true"
+  end
+  # Ssh into the instance or run a command, if the cmd is set
+  def ssh(cmd="")
+    "true"
+  end
+end
+describe "remote instance" do
+  before(:each) do
+    @instance = RemoteInstance.new({:ip => "127.0.0.1", :instance_id => "i-abcdef1"})
+    @instance.stub!(:ssh).and_return true
+    @instance.stub!(:scp).and_return true
+    Kernel.stub!(:system).and_return true
+    
+    @master = Master.new
+  end
+  
+  describe "scping" do
+  end
+  describe "ssh'ing" do
+  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" do
+      @instance.master?.should == true
+    end
+    it "should be able to say that it isn't secondary?" do
+      @instance.secondary?.should_not be_true
+    end
+    it "should be able to build itself a haproxy_resources_entry" do
+      @instance.haproxy_resources_entry.should =~ /node0/
+    end
+    it "should be able to build a list of the heartbeat nodes" do
+      @instance.node_entry.should =~ /node0/
+    end
+    it "should be able to build a hosts_entry for self" do
+      @instance.hosts_entry.should =~ /node0/
+    end
+    it "should be able to have local_hosts_entry with 127.0.0.01" do
+      @instance.local_hosts_entry.should =~ /127\.0\.0\.1/
+    end
+    it "should have a heartbeat_entry" do
+      @instance.heartbeat_entry.should =~ /127\.0\.0\.1/
+      @instance.heartbeat_entry.should =~ /#{Application.managed_services}/
+    end
+    it "should be able to build a haproxy_entry" do
+      @instance.haproxy_entry.should =~ /server/
+    end
+    describe "callbacks" do
+      it "should call configure after it calls install"
+    end
+  end
+    describe "new configuration style (build scripts)" do
+      before(:each) do
+        @tempfile = Tempfile.new("/tmp")
+        Kernel.stub!(:system).and_return true
+      end
+      # it "should try to run the scp build file" do
+      #   Master.should_receive(:build_scp_instances_script_for).with(@instance).and_return @tempfile
+      #   @instance.configure
+      # end
+      # it "should try to run and build the reconfigure script for the node" do
+      #   Master.should_receive(:build_reconfigure_instances_script_for).with(@instance).and_return @tempfile
+      #   @instance.configure
+      # end
+      # it "should scp the reconfigure file to the remote instance" do
+      #   @instance.should_receive(:scp).once.and_return true
+      #   @instance.configure
+      # end
+      # it "should ssh and execute the reconfigure file on the remote instance" do
+      #   @instance.should_receive(:ssh).once.with("chmod +x /usr/local/src/reconfigure.sh && /bin/sh /usr/local/src/reconfigure.sh").and_return true
+      #   @instance.configure
+      # end
+      describe "with a public ip" do
+        before(:each) do
+          Application.stub!(:public_ip).and_return "127.0.0.1"
+        end
+        it "should run associate_address if there is a public_ip set in the Application.options" do
+          @instance.should_receive(:associate_address_with).with(Application.public_ip, @instance.instance_id).and_return true
+          @instance.configure
+        end
+        it "should not run associate_address_with if the public_ip is empty" do
+          Application.stub!(:public_ip).and_return ""
+          @instance.should_not_receive(:associate_address_with)
+          @instance.configure
+        end
+
+    end
+  end  
+  describe "in failover" do
+    it "should be able to become master " do
+      @instance.stub!(:configure).and_return true
+      @instance.number = 1
+      @instance.become_master
+      @instance.number.should == 0
+    end
+    it "should reconfigure after becoming master" do
+      @instance.should_receive(:configure).and_return true
+      @instance.become_master
+    end
+    it "should say that it is the master after becoming master" do
+      @instance.stub!(:configure).and_return true
+      @instance.become_master
+      @instance.master?.should == true
+    end
+    it "should be able to detect is_not_master_and_master_is_not_running? and return false when the server is the master" do
+      @instance.is_not_master_and_master_is_not_running?.should == false
+    end
+    it "should be able to detect is_not_master_and_master_is_not_running? and return false when the master server is responding" do
+      Master.stub!(:is_master_responding?).and_return true
+      @instance.is_not_master_and_master_is_not_running?.should == false
+    end
+    it "should be able to detect is_not_master_and_master_is_not_running? and return false when the master server is responding" do
+      @instance.stub!(:master?).and_return false
+      Master.stub!(:is_master_responding?).and_return false
+      @instance.is_not_master_and_master_is_not_running?.should == true
+    end
+    
+    describe "when installing the poolparty software" do
+      it "should be able to detect if the stack_installed? == false" do
+        @instance.stack_installed?.should == false
+      end
+      it "should set the stack_installed? once installed" do
+        @instance.install
+        @instance.stack_installed?.should == true
+      end
+    end
+    
+    describe "when installing plugins" do
+      it "should call update_plugins after become master" do
+        @instance.should_receive(:update_plugins).at_least(1)
+        @instance.configure
+      end
+      it "should try to install the plugins from the git repos of the installed plugins" do
+        PluginManager.remove_plugin "pool-party-plugins"
+        PluginManager.install_plugin "git@github.com:auser/pool-party-plugins.git"
+        @instance.update_plugin_string.should == ["git@github.com:auser/pool-party-plugins.git"]
+      end
+    end
+    
+  end
+end

data/spec/remoter_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class TestRemote
+  include Remoter
+  include Callbacks
+  attr_accessor :ip
+end
+describe "Remoter" do
+  before(:each) do
+    @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"
+  end
+  it "should have an ssh method that corresponds to ssm with the keypair" do
+    @remoter.ssh_string.should == "ssh -i /Users/id_rsa-app -o StrictHostKeyChecking=no"
+  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/remoting_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + "/helpers/ec2_mock"
+
+describe "Master remoting: " do
+  before(:each) do
+    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 "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.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
+    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.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
+    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/scheduler_spec.rb

@@ -0,0 +1,75 @@
+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
+      it "should add each task as a thread" do
+        Thread.should_receive(:new).once
+        @stasks.push proc{puts "hi"}
+      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 be able to add tasks and have the run_thread_list run" do
+        @test._tasker.class.should_receive(:synchronize).once        
+        @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
+      describe "daemonizing" do
+        it "should detached the process" do
+          Process.should_receive(:detach).once
+          @test.daemonize
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), *%w[.. lib poolparty])
+
+%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.environment = "test"
+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

@@ -0,0 +1,28 @@
+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

data/web/static/conf/nginx.conf

@@ -0,0 +1,22 @@
+server {
+
+    listen   80;
+    server_name  www.poolpartyrb.com;
+    rewrite ^/(.*) http://poolpartyrb.com permanent;
+   }
+
+
+server {
+
+    listen   80;
+    server_name poolpartyrb.com;
+
+    access_log /apps/poolpartyrb/logs/access.log;
+    error_log /apps/poolpartyrb/logs/error.log;
+        
+    location / {    
+      root   /apps/poolpartyrb;
+      index  index.html;
+    }
+
+  }

data/web/static/site/index.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+  <head>
+    <title>PoolParty - Cloud EC2 Computing Made Easy</title>
+    <link href="/stylesheets/reset.css" media="all" rel="stylesheet" type="text/css"/>
+    <link href="/stylesheets/application.css" media="all" rel="stylesheet" type="text/css"/>
+    <script type="text/javascript" src="/javascripts/jquery-1.2.6.pack.js"></script>
+    <script type="text/javascript" src="/javascripts/corner.js"></script>
+    <script type="text/javascript" src="/javascripts/application.js"></script>
+  </head>
+  <body>
+    <div class='container'>
+      <div class='balloon'><img alt="Balloon" src="images/balloon.png"/></div>
+      <div class='header'>
+        <h1><a href="/">PoolParty</a></h1>
+        <div class='clouds'><img alt="Clouds" src="images/clouds.png"/></div>
+        <div class='links'>
+          <a href="#">api</a>
+          <a href="http://poolparty.rubyforge.org/">docs</a>
+          <a href="misc.html">misc</a>
+          <a href="#">group</a>
+        </div>
+        <div class='clear'>
+        </div>
+      </div>
+      <div class='clear'>
+      </div>
+      <div class='content'>
+        <h2>
+          One Ruby <strong><a href="http://github.com/auser/pool-party/tree/master">Gem</a></strong> = easy EC2 computing cloud.
+        </h2>
+        <div class='tout'>
+          <p class='alt'>
+            Amazon's Elastic Compute Cloud provides pay-per-use scalability to the masses.  However, clouds do not have innate load-balancing ability, and there is no native failover solution.
+          </p>
+          <p class='alt'>
+            PoolParty is an <strong>open source</strong> tool that <strong>automates</strong> deployment, monitoring, and load balancing of EC2 instances.  Configure once, and relax by the poolside -- PoolParty will keep your site and its instances afloat.
+          </p>
+        </div>
+        <p>
+          "I'm convinced, how do I get started?"
+          <code>
+            sudo gem install auser-poolparty -s http://gems.github.com
+          </code>
+        </p>
+        <p>
+          "Okay, are there examples or documentation?"
+          <span class='alt'>
+            <a href="http://poolparty.rubyforge.org/">Docs</a>
+            &
+            <a href="#">Examples</a>
+          </span>
+        </p>
+        <p>
+          "How do I extend it?"
+          <p class='alt'>
+            More coming soon
+            <strong>
+              <a href='http://github.com/auser/pool-party-plugins/tree/master'>
+                http://github.com/auser/pool-party-plugins/tree/master
+              </a>
+            </strong>
+          </p>
+        </p>
+      </div>
+      <div class='cb'>
+        <a href="http://www.citrusbyte.com"><img alt="Cb" src="images/cb.png"/></a>
+      </div>
+    </div>
+  </body>
+</html>

data/web/static/site/javascripts/application.js

@@ -0,0 +1,3 @@
+$(document).ready(function() {
+  $(".content").corner();
+});