testbot_cloud 0.1.0

data/.autotest

@@ -0,0 +1,7 @@
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+  # Makes change detection much faster (but CPU usage higher)
+  at.sleep = 0.2
+end
+

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+todo.txt
+tmp
+ec2
+bb
+bb_albert

data/.rvmrc

@@ -0,0 +1 @@
+rvm ree-1.8.7-2011.03@testbot_cloud --create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in testbot_cloud.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,86 @@
+A tool for creating and managing [testbot](https://github.com/joakimk/testbot) clusters in the cloud.
+
+TestbotCloud is based around the idea that you have a project folder for each cluster (which you can store in verison control). You then use the "testbot_cloud" command to start and stop the cluster.
+
+The motivation behind this tool, besides making distributed testing simpler is to be able to run a cluster only when it's needed (by scheduling it with tools like cron).
+
+Installing
+----
+
+    gem install testbot_cloud
+
+Getting started
+----
+
+Using AWS EC2:
+
+* Get a AWS account at [http://aws.amazon.com/](http://aws.amazon.com/).
+* Create a Key Pair.
+* Allow SSH login to a security group. For example: SSH, tcp, 22, 22, 0.0.0.0/0.
+
+Using Brightbox:
+
+* Get a beta account at [http://beta.brightbox.com/beta](http://beta.brightbox.com/beta).
+* Follow [http://docs.brightbox.com/guides/getting_started](http://docs.brightbox.com/guides/getting_started) to setup a SSH key.
+
+Creating a cluster
+----
+
+Create a project
+
+    testbot_cloud new demo
+
+    # create  demo/config.yml
+    # create  demo/.gitignore
+    # create  demo/bootstrap/runner.sh
+
+Start
+
+    cd demo
+    testbot_cloud start
+    
+    # Starting 1 runners...
+    # i-dd2222dd is being created...
+    # i-dd2222dd is up, installing testbot...
+    # i-dd2222dd ready.
+  
+Shutdown
+
+    testbot_cloud stop
+
+    # Shutting down i-dd2222dd...
+
+Debugging
+----
+
+  * Run **DEBUG=true testbot_cloud start** to show all SSH commands and output.
+
+Gotchas
+-----
+
+* Don't create more than 10-15 or so runners at a time (some cloud providers don't allow more than that many connections at once). This might be fixed by batching the creation process in a later version of TestbotCloud.
+
+* Don't create more than 20 runners in total on EC2 as it has a limit by default. See the [EC2 FAQ](http://aws.amazon.com/ec2/faqs) for more info.
+
+Features
+-----
+
+* TestbotCloud is continuously tested for compability with Ruby 1.8.7, 1.9.2, JRuby 1.5.5 and Rubinius 1.1.1.
+* TestbotCloud is designed to be as reliable as possible when starting and stopping so that you can schedule it with tools like cron and save money.
+
+How to add support for additional cloud computing providers
+-----
+
+Basics:
+
+* Look at lib/server/aws.rb and lib/server/brightbox.rb.
+* Write you own and add it to lib/server/factory.rb.
+* Add fog config suitable for the provider to your config.yml.
+
+When contributing:
+
+* Make sure you have the tests running on your machine (should be just running "bundle" and "rake").
+* Write tests.
+* Add a config example to the template at lib/templates/config.yml.
+* Update this readme.
+

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format progress"
+end
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+end
+
+task :default => [ :spec, :features ]

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/bin/testbot_cloud

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/testbot_cloud.rb'))
+
+if ARGV.count == 0
+  puts "TestbotCloud #{TestbotCloud::VERSION}"
+  puts
+end
+
+TestbotCloud::Cli.start
+

data/features/cluster_management.feature

@@ -0,0 +1,13 @@
+Feature: Cluster management
+  In order to run my tests in the cloud
+  As a build monkey 
+  I want to be able to start, stop and check status on the cloud instances
+
+  Scenario: Staring with 2 instances
+    Given I generate a project
+    And I start the testbot cluster
+    Then I should see "Starting 2 runners..."
+    And I should see " up, installing testbot..."
+    And I should see " ready."
+    And I should not see any errors
+

data/features/project_creation.feature

@@ -0,0 +1,14 @@
+Feature: Project creation
+  In order to run my tests in the cloud
+  As a build monkey 
+  I want to create a project that represents my testbot cluster
+
+  Background:
+    Given there is no project
+
+  Scenario: Creating a project
+    When I generate a project
+    Then there should be a project folder
+    And the project folder should contain a config file
+    And the project folder should contain bootstrap files
+

data/features/step_definitions/shared_steps.rb

@@ -0,0 +1,35 @@
+Given /^there is no project$/ do
+  system "rm -rf tmp/cluster"
+end
+
+When /^I generate a project$/ do
+  system("INTEGRATION_TEST=true bin/testbot_cloud new tmp/cluster 1> /dev/null") || raise
+end
+
+Then /^there should be a project folder$/ do
+  File.exists?("tmp/cluster") || raise
+end
+
+Then /^the project folder should contain a config file$/ do
+  File.exists?("tmp/cluster/config.yml") || raise
+end
+
+Then /^the project folder should contain bootstrap files$/ do
+  File.exists?("tmp/cluster/bootstrap/runner.sh") || raise
+end
+
+Given /^I start the testbot cluster$/ do
+  @results = `cd tmp/cluster; INTEGRATION_TEST=true ../../bin/testbot_cloud start 2>&1`
+end
+
+Then /^I should see "([^"]*)"$/ do |text|
+  @results.include?(text) || raise("Did not see '#{text}' in #{@results}")
+end
+
+Then /^I should not see any errors$/ do
+  if @results.include?("testbot_cloud/lib")
+    puts @results
+    raise
+  end
+end
+

data/lib/cli.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'thor'
+require File.expand_path(File.join(File.dirname(__FILE__), 'cluster.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'testbot_cloud/version.rb'))
+
+module TestbotCloud
+  class Cli < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.dirname(__FILE__) + "/templates"
+    end
+
+    desc "new PROJECT_NAME", "Generate a testbot cloud project"
+    def new(name)
+      copy_file "config.yml", "#{name}/config.yml"
+      copy_file "gitignore", "#{name}/.gitignore"
+      copy_file "runner.sh", "#{name}/bootstrap/runner.sh"
+    end
+
+    desc "start", "Start a testbot cluster as configured in config.yml"
+    def start
+      Cluster.new.start
+    end
+
+    desc "stop", "Shutdown servers"
+    def stop
+      Cluster.new.stop
+    end
+
+    desc "version", "Show version"
+    def version
+      puts "TestbotCloud #{TestbotCloud::VERSION}"
+    end
+
+  end
+end
+

data/lib/cluster.rb

@@ -0,0 +1,111 @@
+require 'fog'
+require 'yaml'
+require 'active_support/core_ext/hash/keys'
+require File.expand_path(File.join(File.dirname(__FILE__), 'server/factory.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'servers.rb'))
+
+module TestbotCloud
+  class Cluster
+
+    def initialize
+      Fog.mock! if ENV['INTEGRATION_TEST']
+      if project?
+        load_config
+
+        @compute = Fog::Compute.new(@provider_config)
+      end
+    end
+
+    def start
+      project? || return
+      
+      puts "Starting #{@runner_count} runners..."
+      for_each_runner_in_a_thread do |mutex|
+        server = nil
+        with_retries("server creation") do
+          mutex.synchronize {
+            server = @compute.servers.create(@runner_config) 
+            Servers.log_creation(server)
+
+            # Brightbox API is a bit unstable when creating multiple servers at the same time
+            if @provider_config[:provider] == "Brightbox"
+              # < Caius> joakimk2: yeah, there's a race condition with creating two servers within the 
+              #                   same second currently. We're working on a fix. Workaround is to
+              #                   wait a second or two before creating the second.
+              sleep 3
+            end
+          }
+        end
+        
+        puts "#{server.id} is being created..."
+        with_retries("#{server.id} ready check") do
+          server.wait_for { ready? }          
+        end
+
+        puts "#{server.id} is up, installing testbot..."
+        with_retries("testbot installation") do
+          if Server::Factory.create(@compute, @opts, server).bootstrap!(mutex)
+            puts "#{server.id} ready."
+          else
+            puts "#{server.id} failed, shutting down."
+            server.destroy
+            Servers.log_destruction(server)
+          end
+        end
+      end
+    end
+
+    def stop
+      project? || return
+
+      @compute.servers.each do |server|
+        if Servers.known?(server) && server.ready?
+          puts "Shutting down #{server.id}..."
+          with_retries("server destruction") do
+            server.destroy
+          end
+          Servers.log_destruction(server)
+        end
+      end
+    end
+
+    private
+
+    def project?
+      File.exists?("config.yml")
+    end
+
+    def for_each_runner_in_a_thread
+      threads = []
+      mutex = Mutex.new
+      @runner_count.times do
+        threads << Thread.new do
+          yield mutex
+        end
+      end
+      threads.each { |thread| thread.join }
+    end
+
+    def load_config
+      config = YAML.load_file("config.yml")
+      @provider_config = config["provider"].symbolize_keys
+      @runner_config = config["runner"].symbolize_keys
+      @runner_count = config["runners"]
+      @opts = { :ssh_user => config["ssh_user"] }
+    end
+
+    def with_retries(job)
+      5.times do
+        begin
+          yield
+        rescue Excon::Errors::SocketError => ex
+          puts "#{job} failed, retrying..."
+          sleep 3
+        else
+          break
+        end
+      end
+    end
+
+  end
+end

data/lib/server/aws.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'shared', 'bootstrap.rb'))
+
+module TestbotCloud
+  module Server
+    class AWS
+      def initialize(compute, opts, server)
+        @server, @opts = server, opts
+      end
+
+      def bootstrap!(mutex)
+        # We use the AWS adapter in integration tests.
+        return true if ENV['INTEGRATION_TEST']
+
+        Bootstrap.new(@server.dns_name, @server.id, @opts.merge({ :ssh_opts => "-i testbot.pem" })).install
+      end
+    end
+  end
+end
+

data/lib/server/brightbox.rb

@@ -0,0 +1,38 @@
+module TestbotCloud
+  module Server
+    class Brightbox
+      def initialize(compute, opts, server)
+        @compute, @opts, @server = compute, opts, server
+      end
+
+      def bootstrap!(mutex)
+        ip = nil
+        mutex.synchronize { ip = map_ip! }
+        Bootstrap.new(ip.public_ip, @server.id, @opts).install
+      end
+
+      private
+
+      def map_ip!
+        ip = get_ip
+        ip.map(@server.interfaces.first["id"])
+        ip
+      end
+
+      def get_ip
+        if available_ip = find_available_ip 
+          available_ip
+        else
+          @compute.create_cloud_ip
+          find_available_ip
+        end
+      end
+
+      def find_available_ip
+        @compute.cloud_ips.find { |ip| ip.status == "unmapped" }
+      end
+    end
+  end
+end
+
+

data/lib/server/factory.rb

@@ -0,0 +1,21 @@
+require 'fog/compute/models/slicehost/server'
+require 'fog/compute/models/brightbox/server'
+require 'fog/compute/models/aws/server'
+require File.expand_path(File.join(File.dirname(__FILE__), 'brightbox.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'aws.rb'))
+
+module TestbotCloud
+  module Server
+    class Factory
+      def self.create(compute, opts, server)
+        if server.is_a?(Fog::Brightbox::Compute::Server)
+          Brightbox.new(compute, opts, server)
+        elsif server.is_a?(Fog::AWS::Compute::Server)
+          AWS.new(compute, opts, server)
+        else
+          raise "Unsupported server type: #{server}"
+        end
+      end
+    end
+  end
+end

data/lib/server/shared/bootstrap.rb

@@ -0,0 +1,60 @@
+module TestbotCloud
+  module Server
+    class Bootstrap
+      def initialize(host, id, opts)
+        @host, @id, @opts = host, id, opts
+      end
+
+      def install
+        wait_for_server && upload_bootstrap_files && run('cd bootstrap; sudo sh runner.sh')
+      end
+
+      private
+      
+      def wait_for_server
+        fail_count = 0
+        10.times do
+          if run('true')
+            return true
+          else
+            fail_count += 1
+            
+            # Usally fails atleast once, so better to keep it quiet to begin with
+            if fail_count > 2
+              puts "#{@id} ssh connection failed, retrying..."
+            end
+
+            sleep 3
+          end
+        end
+
+        false
+      end
+
+      def upload_bootstrap_files
+        run_with_debug("scp #{ssh_opts("-r bootstrap")}:~ &> /dev/null")
+      end
+
+      def run(command)
+        run_with_debug("ssh #{ssh_opts} '#{command}' &> /dev/null")
+      end
+
+      def run_with_debug(cmd)
+        if ENV["DEBUG"]
+          puts "DEBUG - CMD: #{cmd}"
+          return_status = system(cmd.gsub(/&.+/, ''))
+          puts "DEBUG - SUCCESS: #{return_status}"
+          return_status
+        else
+          system(cmd)
+        end
+      end
+
+      def ssh_opts(custom_opts = nil)
+        [ "-o StrictHostKeyChecking=no", @opts[:ssh_opts],
+           custom_opts, "#{@opts[:ssh_user]}@#{@host}" ].compact.join(' ')
+      end  
+    end
+  end
+end
+

data/lib/servers.rb

@@ -0,0 +1,15 @@
+module TestbotCloud
+  class Servers
+    def self.log_creation(server)
+      FileUtils.mkdir_p ".servers/#{server.id}"
+    end
+
+    def self.known?(server)
+      File.exists? ".servers/#{server.id}"
+    end
+
+    def self.log_destruction(server)
+      FileUtils.rm_rf ".servers/#{server.id}"
+    end
+  end
+end

data/lib/templates/config.yml

@@ -0,0 +1,53 @@
+# How many instances to run
+runners: 2
+
+# The name of the user provided by the cloud image
+ssh_user: ubuntu
+
+# Using EC2
+provider:
+  provider: AWS
+  aws_access_key_id: AWS_ACCESS_ID
+  aws_secret_access_key: AWS_ACCESS_KEY
+
+runner:
+  key_name: ec2_key
+  groups: default
+  flavor_id: c1.medium
+
+  ### Ubuntu 10.04 images ###
+
+  # 32 bit, ebs (use with t1.micro)
+  #image_id: ami-480df921
+
+  # 32 bit, instance
+  image_id: ami-480df921
+
+  # 64 bit, instance
+  #image_id: ami-da0cf8b3
+
+  # Has the cheapest instances
+  region: us-east-1
+
+# Using Brightbox
+#provider:
+#  provider: Brightbox
+#  brightbox_client_id: cli-XXXXX
+#  brightbox_secret: xxx
+# 
+#runner:
+#  # Ubuntu 10.04, 32 bit
+#  image_id: img-hm6oj
+#  
+#  # 4 cores, 1 GB (256 MB / core)
+#  flavor_id: typ-iqisj
+#
+#  # 2 cores, 512 MB (256 MB / core)
+#  # flavor_id: typ-4nssg
+#
+#  # 4 cores, 2 GB (512 MB / core)
+#  # flavor_id: typ-urtky
+#  
+#  # 8 cores, 4 GB (512 MB / core)
+#  # flavor_id: typ-qdiwq
+

data/lib/templates/gitignore

@@ -0,0 +1 @@
+.servers

data/lib/templates/runner.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+export DEBIAN_FRONTEND=noninteractive
+
+apt-get update &&
+apt-get -y install curl wget ruby ruby-dev libopenssl-ruby &&
+wget http://production.cf.rubygems.org/rubygems/rubygems-1.3.7.tgz &&
+tar xvfz rubygems-1.3.7.tgz && cd rubygems-1.3.7 && ruby setup.rb && ln -s /usr/bin/gem1.8 /usr/bin/gem
+
+su ubuntu -c 'GEM_HOME="~/.gem" gem install testbot --no-ri --no-rdoc'
+
+# Ramdisk for fast rsync
+echo 'none            /tmp            tmpfs   defaults        0       0' >> /etc/fstab
+mount -a
+
+cd /home/ubuntu
+mv bootstrap/ssh/* .ssh/
+chown -R ubuntu .ssh
+chmod 0600 .ssh/id_rsa
+
+# TODO:
+# Haven't gotten auto_update to run using this cloud setup
+# script yet, it updates but does not restart the process. 
+
+su ubuntu -c 'export PATH="$HOME/.gem/bin:$PATH"; export GEM_HOME="$HOME/.gem"; testbot --runner --ssh_tunnel --auto_update --connect your_server_host'
+

data/lib/testbot_cloud.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'cli.rb'))
+
+module TestbotCloud
+end
+

data/lib/testbot_cloud/version.rb

@@ -0,0 +1,3 @@
+module TestbotCloud
+  VERSION = "0.1.0"
+end

data/spec/cli_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper.rb'))
+
+describe TestbotCloud::Cli do
+
+  it "should include Thor::Actions" do
+    TestbotCloud::Cli.included_modules.should include(Thor::Actions)
+  end
+
+  it "should set source_root to lib/templates" do
+    TestbotCloud::Cli.source_root.should include("lib/templates")
+  end
+
+  describe "when calling new with a project name" do
+
+    it "should generate a project" do
+      cli = TestbotCloud::Cli.new
+      cli.should_receive(:copy_file).with("config.yml", "app_name/config.yml")
+      cli.should_receive(:copy_file).with("gitignore", "app_name/.gitignore")
+      cli.should_receive(:copy_file).with("runner.sh", "app_name/bootstrap/runner.sh") 
+      cli.new("app_name")
+    end
+
+  end
+
+  describe "when calling start" do
+    
+    it "should start a cluster" do
+      TestbotCloud::Cluster.stub!(:new).and_return(cluster = mock(Object))
+      cluster.should_receive(:start)
+      TestbotCloud::Cli.new.start
+    end
+
+  end
+
+  describe "when calling stop" do
+
+    it "should stop a cluster" do
+      TestbotCloud::Cluster.stub!(:new).and_return(cluster = mock(Object))
+      cluster.should_receive(:stop)
+      TestbotCloud::Cli.new.stop
+    end
+
+  end
+
+  describe "when calling version" do
+
+    it "should print the version" do
+      cli = TestbotCloud::Cli.new
+      cli.should_receive(:puts).with("TestbotCloud #{TestbotCloud::VERSION}")
+      cli.version
+    end
+
+  end
+
+end
+

data/spec/cluster_spec.rb

@@ -0,0 +1,223 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper.rb'))
+
+describe TestbotCloud::Cluster do
+
+  describe "when not in a project" do
+
+    it "should do nothing if there is no config.yml file" do
+      File.should_receive(:exists?).any_number_of_times.with("config.yml").and_return(false)
+      cluster = TestbotCloud::Cluster.new
+      cluster.start
+      cluster.stop
+    end
+
+  end
+
+  describe "when calling start" do
+
+    before do
+      File.stub!(:exists?).with("config.yml").and_return(true)
+      YAML.should_receive(:load_file).with("config.yml").and_return({
+        "runners" => 2,
+        "ssh_user" => "ubuntu",
+        "provider" => {
+          "provider" => "AWS",
+          "aws_access_key_id" => "KEY_ID"
+        },
+        "runner" => {
+          "image_id" => "ami-xxxx"
+        }  
+      });
+
+      FileUtils.stub!(:mkdir_p)
+      Fog::Compute.should_receive(:new).with({ :provider => "AWS",
+                                               :aws_access_key_id => "KEY_ID" }).
+                                        and_return(@compute = mock(Object))
+      @compute.stub!(:servers).and_return(mock(Object))
+    end
+
+    it "should create servers based on config.yml" do
+      @compute.servers.should_receive(:create).twice.with(:image_id => "ami-xxxx").
+                       and_return(fog_server = mock(Object, :id => nil, :wait_for => nil))
+
+      TestbotCloud::Server::Factory.should_receive(:create).twice.with(@compute, { :ssh_user => 'ubuntu' }, fog_server).
+                                     and_return(server = mock(Object))
+      server.should_receive(:bootstrap!).twice.and_return(true)
+
+      cluster = TestbotCloud::Cluster.new
+      cluster.stub!(:puts)
+      cluster.start
+    end
+
+    it "should log the servers that are created" do
+      @compute.servers.stub!(:create).and_return(mock(Object, :id => "srv-boo", :wait_for => nil),
+                                                 mock(Object, :id => "srv-doo", :wait_for => nil))
+
+      TestbotCloud::Server::Factory.should_receive(:create).twice.and_return(server = mock(Object))
+      server.stub!(:bootstrap!).and_return(true)
+
+      FileUtils.should_receive(:mkdir_p).with(".servers/srv-boo")
+      FileUtils.should_receive(:mkdir_p).with(".servers/srv-doo")
+
+      cluster = TestbotCloud::Cluster.new
+      cluster.stub!(:puts)
+      cluster.stub!(:sleep)
+      cluster.start
+    end
+
+    it "should destroy the server if bootstrap fails" do
+      @compute.servers.stub!(:create).and_return(fog_server0 = mock(Object, :id => "srv-boo", :wait_for => nil),
+                                                 fog_server1 = mock(Object, :id => "srv-moo", :wait_for => nil))
+
+      TestbotCloud::Server::Factory.should_receive(:create).twice.and_return(server = mock(Object))
+      server.stub!(:bootstrap!).and_return(false)
+
+      FileUtils.should_receive(:rm_rf).with(".servers/srv-moo")
+      FileUtils.should_receive(:rm_rf).with(".servers/srv-boo")
+
+      fog_server0.should_receive(:destroy)
+      fog_server1.should_receive(:destroy)
+
+      cluster = TestbotCloud::Cluster.new
+      cluster.stub!(:puts)
+      cluster.start
+    end
+
+    it "should retry server create if it fails with a socket error" do
+      class OpenStructWithQuietId < OpenStruct; def id; end; end
+      class SocketErrorFogServerCollection
+        attr_reader :id
+
+        def create(opts)
+          unless @called_once
+            @called_once = true
+            raise Excon::Errors::SocketError.new(Exception.new)
+          else
+            return OpenStructWithQuietId.new
+          end
+        end
+      end
+
+      @compute.stub!(:servers).and_return(SocketErrorFogServerCollection.new)
+        
+      TestbotCloud::Server::Factory.should_receive(:create).twice.
+                                    and_return(server = mock(Object))
+      server.stub!(:bootstrap!).and_return(true)
+
+      cluster = TestbotCloud::Cluster.new
+      cluster.stub!(:puts)
+      cluster.stub!(:sleep)
+      cluster.start
+    end
+
+    it "should retry wait for ready if it fails with a socket error" do
+      class SocketErrorFogServer
+        attr_reader :id
+
+        def wait_for
+          unless @called_once
+            @called_once = true
+            raise Excon::Errors::SocketError.new(Exception.new)
+          else
+            return true
+          end
+        end
+      end
+
+      @compute.servers.stub!(:create).and_return(fog_server = SocketErrorFogServer.new)
+
+      TestbotCloud::Server::Factory.should_receive(:create).twice.with(@compute,
+                                    { :ssh_user => "ubuntu" }, fog_server).
+                                    and_return(server = mock(Object))
+      server.stub!(:bootstrap!).and_return(true)
+
+      cluster = TestbotCloud::Cluster.new
+      cluster.stub!(:puts)
+      cluster.stub!(:sleep)
+      cluster.start
+    end
+
+    it "should retry bootstrap if it fails with a socket error" do
+      @compute.servers.stub!(:create).and_return(mock(Object, :id => nil, :wait_for => nil))
+
+      class SocketErrorServer
+        def bootstrap!(mutex) 
+          unless @called_once
+            @called_once = true
+            raise Excon::Errors::SocketError.new(Exception.new)
+          else
+            return true
+          end
+        end
+      end
+
+      TestbotCloud::Server::Factory.stub!(:create).and_return(SocketErrorServer.new)
+
+      cluster = TestbotCloud::Cluster.new
+      cluster.stub!(:puts)
+      cluster.stub!(:sleep)
+      cluster.start
+    end
+
+  end
+
+  describe "when calling stop" do
+
+    before do
+      File.stub!(:exists?).with("config.yml").and_return(true)
+      YAML.should_receive(:load_file).with("config.yml").and_return({
+         "provider" => {
+           "provider" => "AWS",
+           "aws_access_key_id" => "KEY_ID"
+         },
+         "runner" => {},
+         "runners" => 0
+      });
+      
+      Fog::Compute.should_receive(:new).with({ :provider => "AWS",
+                                                :aws_access_key_id => "KEY_ID" }).
+                                         and_return(@compute = mock(Object))
+    end
+
+    it "should stop servers that are listed in the log file and ready" do
+      @compute.stub!(:servers).and_return([ mock(Object, :ready? => false, :id => "srv-boo"), 
+                                            server = mock(Object, :ready? => true, :id => "srv-moo"),
+                                            unrelated_server = mock(Object, :ready? => true, :id => "srv-ahh") ])
+
+      File.should_receive(:exists?).with(".servers/srv-boo").and_return(true)
+      File.should_receive(:exists?).with(".servers/srv-moo").and_return(true)
+      File.should_receive(:exists?).with(".servers/srv-ahh").and_return(false)
+      FileUtils.should_receive(:rm_rf).with(".servers/srv-moo")
+      server.should_receive(:destroy)
+
+      cluster = TestbotCloud::Cluster.new
+      cluster.stub!(:puts)
+      cluster.stop
+    end
+
+    it "should retry destroy if it fails with a socket error" do
+      class SocketErrorServer
+        def id; "srv-moo"; end
+        def ready?; true; end
+
+        def destroy
+          return if @called_once
+          @called_once = true
+          raise Excon::Errors::SocketError.new(Exception.new)
+        end
+      end
+
+      @compute.stub!(:servers).and_return([ server = SocketErrorServer.new ]) 
+                                            
+      File.should_receive(:exists?).with(".servers/srv-moo").and_return(true)
+      FileUtils.should_receive(:rm_rf).with(".servers/srv-moo")
+
+      cluster = TestbotCloud::Cluster.new
+      cluster.stub!(:puts)
+      cluster.stub!(:sleep)
+      cluster.stop
+    end
+
+  end
+
+end

data/spec/server/aws_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper.rb'))
+
+describe TestbotCloud::Server::AWS, "bootstrap!" do
+
+  it "should run bootstrap" do
+    fog_server = mock(:dns_name => "example.com", :id => "i-500")
+
+    TestbotCloud::Server::Bootstrap.should_receive(:new).with("example.com", "i-500",
+                                                              :ssh_opts => "-i testbot.pem",
+                                                              :ssh_user => "ubuntu").
+                                                              and_return(bootstrap = mock)
+    bootstrap.should_receive(:install)
+    server = TestbotCloud::Server::AWS.new(nil, { :ssh_user => "ubuntu" }, fog_server)
+    server.bootstrap!(nil)
+  end
+
+end
+

data/spec/server/brightbox_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper.rb'))
+
+describe TestbotCloud::Server::Brightbox, "bootstrap!" do
+
+  before :each do
+    TestbotCloud::Server::Bootstrap.stub!(:new).and_return(mock(:install => true))
+  end
+
+  it "should find unmapped ips and map to the server" do
+    compute = mock(Object, :cloud_ips =>
+                   [ mock(Object, :status => "mapped"),
+                     available_ip = mock(Object, :status => "unmapped", :public_ip => nil) ])
+    fog_server = mock(Object, :interfaces => [ { "id" => "int-xxyyy" } ], :id => nil)
+    server = TestbotCloud::Server::Brightbox.new(compute, {}, fog_server)
+
+    available_ip.should_receive(:map).with("int-xxyyy")
+    server.bootstrap!(Mutex.new)
+  end
+
+  it "should create a cloud ip and map when none are available" do
+    # Found no good way to assert the order of events other than creating a custom mock class.
+    class ComputeWithNoFreeIps
+      def initialize; @cloud_ips = []; end
+      attr_reader :cloud_ips
+
+      def create_cloud_ip
+        @cloud_ips << OpenStruct.new(:status => "unmapped")
+        @cloud_ips.last.should_receive(:map).with("int-xxyyy")
+      end
+    end
+
+    compute = ComputeWithNoFreeIps.new
+    fog_server = mock(Object, :interfaces => [ { "id" => "int-xxyyy" } ], :id => nil)
+    server = TestbotCloud::Server::Brightbox.new(compute, {}, fog_server)
+
+    server.bootstrap!(Mutex.new)
+  end
+
+end

data/spec/server/factory_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper.rb'))
+
+describe TestbotCloud::Server::Factory do
+  
+  it "should create a server wrapper for Brightbox" do
+    server = TestbotCloud::Server::Factory.create(nil, nil, Fog::Brightbox::Compute::Server.new)
+    server.should be_instance_of(TestbotCloud::Server::Brightbox)
+  end
+
+  it "should create a server wrapper for AWS" do
+    server = TestbotCloud::Server::Factory.create(nil, nil, Fog::AWS::Compute::Server.new)
+    server.should be_instance_of(TestbotCloud::Server::AWS)
+  end
+
+  it "should raise an error when there is no server wrapper" do
+    expect {
+      TestbotCloud::Server::Factory.create(nil, nil, Fog::Slicehost::Compute::Server.new)
+    }.to raise_error(/Unsupported server type: /)
+  end
+
+
+end

data/spec/server/shared/bootstrap_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../spec_helper.rb'))
+
+describe TestbotCloud::Server::Bootstrap do
+
+  it "should be able to upload bootstrap files and run them" do
+    bootstrap = TestbotCloud::Server::Bootstrap.new("15.14.13.12", "srv-foo", { :ssh_user => "ubuntu" })
+
+    bootstrap.should_receive(:system).and_return(true)
+    bootstrap.should_receive(:system).with("scp -o StrictHostKeyChecking=no -r bootstrap ubuntu@15.14.13.12:~ &> /dev/null").and_return(true)
+    bootstrap.should_receive(:system).with("ssh -o StrictHostKeyChecking=no ubuntu@15.14.13.12 'cd bootstrap; sudo sh runner.sh' &> /dev/null").and_return(true)
+
+    bootstrap.stub!(:sleep)
+    bootstrap.install
+  end
+
+  it "should try to get a connection going before running bootstrap" do
+    bootstrap = TestbotCloud::Server::Bootstrap.new("15.14.13.12", "srv-foo", { :ssh_user => "ubuntu" })
+
+    bootstrap.should_receive(:system).and_return(false)
+    bootstrap.should_receive(:system).and_return(false)
+    bootstrap.should_receive(:system).and_return(true)
+    bootstrap.should_receive(:system).with("scp -o StrictHostKeyChecking=no -r bootstrap ubuntu@15.14.13.12:~ &> /dev/null").and_return(true)
+    bootstrap.should_receive(:system).with("ssh -o StrictHostKeyChecking=no ubuntu@15.14.13.12 'cd bootstrap; sudo sh runner.sh' &> /dev/null").and_return(true)
+
+    bootstrap.stub!(:sleep).any_number_of_times
+    bootstrap.install
+  end
+
+  it "should not try to bootstrap if the connection fails" do
+    bootstrap = TestbotCloud::Server::Bootstrap.new("15.14.13.12", "srv-foo", { :ssh_user => "ubuntu" })
+    bootstrap.stub!(:system).and_return(false)
+    bootstrap.should_not_receive(:system).with("scp -o StrictHostKeyChecking=no -r bootstrap ubuntu@15.14.13.12:~ &> /dev/null")
+
+    bootstrap.stub!(:sleep)
+    bootstrap.stub!(:puts)
+    bootstrap.install
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/testbot_cloud.rb'))

data/testbot_cloud.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "testbot_cloud/version"
+
+Gem::Specification.new do |s|
+  s.name        = "testbot_cloud"
+  s.version     = TestbotCloud::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joakim Kolsjö"]
+  s.email       = ["joakim.kolsjo@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Run your tests in the cloud}
+  s.description = %q{A tool for creating and managing testbot clusters in the cloud}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "thor", ">0.14.5"
+  s.add_dependency "fog", ">0.7.1"
+  s.add_dependency "activesupport", ">3.0.0"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "cucumber"
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification 
+name: testbot_cloud
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Joakim Kolsj\xC3\xB6"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-17 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 45
+        segments: 
+        - 0
+        - 14
+        - 5
+        version: 0.14.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: fog
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 0
+        - 7
+        - 1
+        version: 0.7.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: A tool for creating and managing testbot clusters in the cloud
+email: 
+- joakim.kolsjo@gmail.com
+executables: 
+- testbot_cloud
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gemtest
+- .gitignore
+- .rvmrc
+- CHANGELOG
+- Gemfile
+- README.markdown
+- Rakefile
+- autotest/discover.rb
+- bin/testbot_cloud
+- features/cluster_management.feature
+- features/project_creation.feature
+- features/step_definitions/shared_steps.rb
+- lib/cli.rb
+- lib/cluster.rb
+- lib/server/aws.rb
+- lib/server/brightbox.rb
+- lib/server/factory.rb
+- lib/server/shared/bootstrap.rb
+- lib/servers.rb
+- lib/templates/config.yml
+- lib/templates/gitignore
+- lib/templates/runner.sh
+- lib/testbot_cloud.rb
+- lib/testbot_cloud/version.rb
+- spec/cli_spec.rb
+- spec/cluster_spec.rb
+- spec/server/aws_spec.rb
+- spec/server/brightbox_spec.rb
+- spec/server/factory_spec.rb
+- spec/server/shared/bootstrap_spec.rb
+- spec/spec_helper.rb
+- testbot_cloud.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Run your tests in the cloud
+test_files: []
+