ciborg 0.0.1 → 3.0.0

data/lib/ciborg/configuration_wizard.rb

@@ -0,0 +1,122 @@
+require "thor"
+
+module Ciborg
+  class ConfigurationWizard < ::Thor
+    include Actions
+
+    DESCRIPTION_TEXT = "Sets up ciborg through a series of questions"
+
+    default_task :setup
+
+    desc "setup", DESCRIPTION_TEXT
+    def setup
+      return unless yes?("It looks like you're trying to set up a CI Box. Can I help? (Yes/No)")
+      prompt_for_build
+      prompt_for_github_key
+      prompt_for_ssh_key
+      prompt_for_aws
+      prompt_for_security_group
+      prompt_for_basic_auth
+      config.save
+      say config.reload.display
+      if user_wants_to_create_instance?
+        create_instance
+        provision_server
+      end
+    end
+
+    no_tasks do
+      def ask_with_default(statement, default)
+        question = default ? "#{statement} [#{default}]:" : "#{statement}:"
+        answer = ask(question) || ""
+        answer.empty? ? default : answer
+      end
+
+      def prompt_for_aws
+        say("For your AWS Access Key and Secret, see https://aws-portal.amazon.com/gp/aws/developer/account/index.html?ie=UTF8&action=access-key")
+        config.aws_key = ask_with_default("Your AWS key", config.aws_key)
+        config.aws_secret = ask_with_default("Your AWS secret key", config.aws_secret)
+      end
+
+      def prompt_for_security_group
+        config.security_group = ask_with_default("What EC2 security group would you like to use?", config.security_group)
+      end
+
+      def prompt_for_basic_auth
+        config.node_attributes.nginx.basic_auth_user = ask_with_default("Your CI username", config.node_attributes.nginx.basic_auth_user)
+        config.node_attributes.nginx.basic_auth_password = ask_with_default("Your CI password", config.node_attributes.nginx.basic_auth_password)
+      end
+
+      def prompt_for_ssh_key
+        config.server_ssh_key = ask_with_default("Path to CI server SSH key", config.server_ssh_key_path)
+      end
+
+      def prompt_for_github_key
+        config.github_ssh_key = ask_with_default("Path to a SSH key authorized to clone the repository", config.github_ssh_key_path)
+      end
+
+      def prompt_for_build
+        build = config.node_attributes.jenkins.builds.first || {}
+
+        if this_is_a_rails_project? && prompt_for_default_rails_script
+          build_command = Proc.new { "script/ci_build.sh" }
+          copy_file('default_rails_build_script.sh', 'script/ci_build.sh')
+        else
+          build_command = Proc.new { ask_with_default("What command should be run during the build?", build["command"]) }
+        end
+
+        repository = ask_with_default("What is the address of your git repository?", build["repository"])
+        name = ask_with_default("What would you like to name your build?", build["name"])
+        command = build_command.call
+        branch = "master"
+
+        config.add_build name, repository, branch, command
+      end
+
+      def user_wants_to_create_instance?
+        return unless config.master.nil?
+        yes?("Would you like to start an instance on AWS now? (Yes/No)")
+      end
+
+      def create_instance
+        say("Creating instance #{config.instance_size}")
+        cli.create
+        say("Instance launched.")
+      end
+
+      def provision_server
+        return if config.reload.master.nil?
+        cli.bootstrap
+        cli.chef
+      end
+
+      def config
+        @config ||= Ciborg::Config.from_file(ciborg_config_path)
+      end
+    end
+
+    private
+
+    def source_paths
+      [File.join(File.expand_path(File.dirname(__FILE__)), "templates")] + super
+    end
+
+    def prompt_for_default_rails_script
+      return false if File.exists?('script/ci_build.sh')
+      yes?("It looks like this is a Rails project.  Would you like to use the default Rails build script? (Yes/No)")
+    end
+
+    def this_is_a_rails_project?
+      File.exists?('script/rails')
+    end
+
+    def ciborg_config_path
+      FileUtils.mkdir_p(File.join(Dir.pwd, "config"))
+      File.expand_path("config/ciborg.yml", Dir.pwd)
+    end
+
+    def cli
+      Ciborg::CLI.new
+    end
+  end
+end

data/lib/ciborg/keychain.rb

@@ -0,0 +1,36 @@
+require "httpclient"
+
+module Ciborg
+  class Keychain
+    attr_reader :config, :path
+
+    def initialize(keychain_path)
+      @path = keychain_path
+    end
+
+    def has_key?(key_name)
+      system("sudo security find-certificate -c \"#{key_name}\" #{path} > /dev/null 2>&1")
+    end
+
+    def fetch_remote_certificate(host)
+      http_client.get(host).peer_cert.to_s
+    end
+
+    def add_certificate(certificate)
+      certificate_file = Tempfile.new("ciborg.crt").tap do |f|
+        f.write(certificate)
+        f.close
+      end
+
+      system("sudo security add-trusted-cert -d -r trustAsRoot -k /Library/Keychains/System.keychain #{certificate_file.path}")
+    end
+
+    private
+    def http_client
+      @http_client ||=
+        HTTPClient.new.tap do |hc|
+          hc.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+    end
+  end
+end

data/lib/ciborg/password.rb

@@ -0,0 +1,13 @@
+require "haddock"
+
+module Ciborg
+  class Password
+    class << self
+      def generate
+        Haddock::Password.generate
+      rescue Haddock::Password::NoWordsError
+        return ""
+      end
+    end
+  end
+end

data/lib/ciborg/sobo.rb

@@ -0,0 +1,79 @@
+require 'net/ssh'
+require 'shellwords'
+module Ciborg
+  class Sobo
+    class CommandFailed < StandardError; end;
+
+    attr_reader :ip, :key, :user
+    attr_writer :timeout
+
+    def initialize(ip, key, user='ubuntu')
+      @ip = ip
+      @key = key
+      @user = user
+    end
+
+    def timeout
+      @timeout || 10000
+    end
+
+    def system(command)
+      ssh_popen4!(command, true)[2]
+    end
+
+    def system!(command)
+      result = ssh_popen4!(command, true)
+      raise(CommandFailed, "Failed: #{command}\n#{result[0]}\n\n#{result[1]}") unless result[2] == 0
+    end
+
+    def backtick(command)
+      ssh_popen4!(command)[0]
+    end
+
+    def ssh_popen4!(command, streaming_output = false)
+      ssh = Net::SSH.start(ip, user, :keys => [key], :timeout => timeout, paranoid: false)
+      stdout_data = ""
+      stderr_data = ""
+      exit_code = nil
+      exit_signal = nil
+
+      ssh.open_channel do |channel|
+        channel.exec("/bin/bash -lc #{Shellwords.escape(command)}") do |ch, success|
+          unless success
+            raise "FAILED: couldn't execute command (ssh.channel.exec)"
+          end
+
+          channel.on_data do |ch,data|
+            if streaming_output
+              STDOUT << data
+              STDOUT.flush
+            end
+            stdout_data += data
+          end
+
+          channel.on_extended_data do |ch,type,data|
+            if streaming_output
+              STDERR << data
+              STDERR.flush
+            end
+            stderr_data += data
+          end
+
+          channel.on_request("exit-status") do |ch,data|
+            exit_code = data.read_long
+          end
+
+          channel.on_request("exit-signal") do |ch, data|
+            exit_signal = data.read_long
+          end
+        end
+      end
+      ssh.loop
+      [stdout_data, stderr_data, exit_code, exit_signal]
+    end
+
+    def upload(from, to, opts = "--exclude .git")
+      Kernel.system(%Q{rsync --rsh="ssh -o 'StrictHostKeyChecking no' -i #{key}" --archive --compress --delete #{from} #{user}@#{ip}:#{to} #{opts}})
+    end
+  end
+end

data/lib/ciborg/templates/default_rails_build_script.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -le
+
+source .rvmrc
+
+# install bundler if necessary
+set -e
+
+gem install bundler --no-ri --no-rdoc && bundle install
+
+# debugging info
+echo USER=$USER && ruby --version && which ruby && which bundle
+
+bundle exec rspec spec

data/lib/ciborg/version.rb

@@ -1,3 +1,3 @@
 module Ciborg
-  VERSION = "0.0.1"
+  VERSION = "3.0.0"
 end

data/script/bootstrap_server.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+
+set -e
+
+sudo apt-get update > /dev/null
+
+packages="git build-essential openssl libreadline6 libreadline6-dev libreadline5 curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev autoconf libc6-dev libncurses5-dev automake libtool bison subversion pkg-config"
+selections=`dpkg --get-selections`
+
+for package in $packages
+do
+  if ! echo "$selections" | grep "^$package\s" > /dev/null
+  then
+    to_install="$to_install $package"
+  fi
+done
+
+if [ ! -z "$to_install" ]
+then
+	sudo apt-get install -y $to_install
+fi
+
+test -d /usr/local/rvm || curl --location https://get.rvm.io | sudo bash -s stable
+
+sudo tee /etc/profile.d/rvm.sh > /dev/null <<RVMSH_CONTENT
+[[ -s "/usr/local/rvm/scripts/rvm" ]] && source "/usr/local/rvm/scripts/rvm"
+RVMSH_CONTENT
+
+sudo tee /etc/rvmrc > /dev/null <<RVMRC_CONTENTS
+rvm_install_on_use_flag=1
+rvm_trust_rvmrcs_flag=1
+rvm_gemset_create_on_use_flag=1
+RVMRC_CONTENTS
+
+sudo usermod ubuntu -a -G rvm

data/script/ci_build.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -le
+
+source .rvmrc
+
+# install bundler if necessary
+set -e
+
+gem install bundler --no-ri --no-rdoc && bundle install
+
+# debugging info
+echo USER=$USER && ruby --version && which ruby && which bundle
+
+bundle exec rspec spec --tag ~slow --tag ~vagrant --tag ~osx

data/spec/assets/test_cert.crt

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICazCCAdQCCQDiA9ObNgBXmTANBgkqhkiG9w0BAQUFADB6MQswCQYDVQQGEwJB
+VTEMMAoGA1UECBMDTlNXMQ8wDQYDVQQHEwZTeWRuZXkxFzAVBgNVBAoTDk15IE9y
+ZyBQdHkgTHRkMREwDwYDVQQLEwhPcmcgVW5pdDEgMB4GA1UEAxQXY2lib3JnX3Rl
+c3RfY2VydGlmaWNhdGUwHhcNMTMwNDIzMTcxMjU4WhcNMTMwNTIzMTcxMjU4WjB6
+MQswCQYDVQQGEwJBVTEMMAoGA1UECBMDTlNXMQ8wDQYDVQQHEwZTeWRuZXkxFzAV
+BgNVBAoTDk15IE9yZyBQdHkgTHRkMREwDwYDVQQLEwhPcmcgVW5pdDEgMB4GA1UE
+AxQXY2lib3JnX3Rlc3RfY2VydGlmaWNhdGUwgZ8wDQYJKoZIhvcNAQEBBQADgY0A
+MIGJAoGBALFFaiUwevz7QcfT7AyUR34VnTQJQ4BErRjpqbgLvuEP8zKFAIESC3Zr
+AZIBvXw9UX1iHSON2zpRyZzlCXuzVHC7WbWPPFDLf22G7v03OxEytPqRB5bM5dAu
+rgn2EsTb4CY7e/PKFSrE2bvfOSmewUyUAmqD9/qN0HwN9k9OpzS7AgMBAAEwDQYJ
+KoZIhvcNAQEFBQADgYEASMExTjGijIElwr87yZVLeMp8jwtRTCpooRl/lWuSsX/9
+mbQKQFYjH/b1FSeJ+mXhszbig/XnY0dlwmjXZtybMT5yWJ6f/AOw6iH1BTLPCt72
+OZ4b4ku8oIknwX9lJa5/75ljC450jc2OKEArHvpkg6LV2iadVJiqP1in6JKK0yM=
+-----END CERTIFICATE-----

data/spec/assets/test_cert.csr

@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIBujCCASMCAQAwejELMAkGA1UEBhMCQVUxDDAKBgNVBAgTA05TVzEPMA0GA1UE
+BxMGU3lkbmV5MRcwFQYDVQQKEw5NeSBPcmcgUHR5IEx0ZDERMA8GA1UECxMIT3Jn
+IFVuaXQxIDAeBgNVBAMUF2NpYm9yZ190ZXN0X2NlcnRpZmljYXRlMIGfMA0GCSqG
+SIb3DQEBAQUAA4GNADCBiQKBgQCxRWolMHr8+0HH0+wMlEd+FZ00CUOARK0Y6am4
+C77hD/MyhQCBEgt2awGSAb18PVF9Yh0jjds6Ucmc5Ql7s1Rwu1m1jzxQy39thu79
+NzsRMrT6kQeWzOXQLq4J9hLE2+AmO3vzyhUqxNm73zkpnsFMlAJqg/f6jdB8DfZP
+Tqc0uwIDAQABoAAwDQYJKoZIhvcNAQEFBQADgYEAl3V2LPi8tWNhDrC1WIGHEGjc
+rm98ZaAkS3x8PYnIgurZ7wT4yFsO34DvVFJTbE7m8coaJ9+Lb23WDaKZawGnVkMx
+ajO98/teArmYlaNX2tvQ+n0++mwlq95yDj9S1N5+H5gUtC/5M1o/pTg3NGNahKbS
+fF24B+h0XRc+TqwWwgs=
+-----END CERTIFICATE REQUEST-----

data/spec/assets/test_cert.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQCxRWolMHr8+0HH0+wMlEd+FZ00CUOARK0Y6am4C77hD/MyhQCB
+Egt2awGSAb18PVF9Yh0jjds6Ucmc5Ql7s1Rwu1m1jzxQy39thu79NzsRMrT6kQeW
+zOXQLq4J9hLE2+AmO3vzyhUqxNm73zkpnsFMlAJqg/f6jdB8DfZPTqc0uwIDAQAB
+AoGAM4f1KihkqCO15IvjQ2jbO3i3AQhsWd4c33AVSQ4JB82mKZpmIh8Hu/2xMCtX
+VMVSaftacxpqjxJ1ZClkT1Q7CCn/OgvNFyuRlNhn7KqwE3gPTxQmi1A8vFi8InPM
+hqDFfhd1Se/cu9xznq3cfR/S9YlIXxWQ9xI/Bq0AkYvOyzECQQDmrNxAnhoHpWMb
+c1SpHhO9BZkm8Bo0HRKdGuJMcJyRyW3URfTn8ROUMNTGn6GQIX6leGN4hLm179Q5
+ZqfwFItJAkEAxLuhMPWZX/W3dMjzWqaP8PpqD+Pd2QdaGNu3LWBHy+9PRJcr0RRi
+v06Zpg4krofd//uA1KakwzWONFPnHMcb4wJBAMiOemDkFRWYwfZX67+uGtM5TtL/
+5ohwzoIxoZd8QWSvkQICYNBYVgF+A0E+ASZjOM19Ql7CZwS8I/RUQKcH9aECQQCu
+yIf4CGtgXtzDq/jQ0+RUUxZB0c96jtaT+Thv3vdKju1c4fWyxqrIjlthtXUPfnRU
+hay6wObm68DQaq6M2bTDAkEA40ZcUTPi7OqG6tSW1ZKyWmyhPfpbznfqHU7zLRil
+A76GespDkkEpvu+OBu/FZx4MjFwDIDIqb11pw9xqMDJHbg==
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/ssh_keys/vagrant_test_key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEA3ItezXAizPua9JTKlxN5D3Q3RUNT7TXUbqfg3XmEEEOIcidc
+yAAqG+4XVbp7Fjv80ADSWTrZzJN5/rfr762/zvupBEmDsHcaSaWo6MCTnek6uBPR
+I7GwFh17zKtjrXNdZqKyHn6STwdcar5hh282sqbs7TJjVVnSLuJbjTZEsSVS3r3/
+CVhWTxVQbis/fgE7IQkGCKDDtEJtXRR3VBtDz5n5Ez0aefsjUxtcgSJKLJoVJrOM
+DVO/rIvbiAEBXy3uZsFi9uSvTp0nIyE5t8GPoQeG8pgcgiahNOy+sIiWcbK5BXrb
+SrdWi0NfW+2CfJGzJXo2Fs09QVzpUyts2GAqaQIDAQABAoIBAQC9ab2MN4jMADO/
+Z6LvSbwpd6iYhhCopBjEyM4pqNmxli6zy/a1lt6TilLkP/rCx9aDVpFSLWctemPG
+TnQGL3WS8TTiB7lgb4pWQj7lV6/waYUS34I5Y7xV4hCXYYOETpajNYxBAHfsA+ht
+jQD6bpvNp+vIdAQ4I6KOvb3fdAJfGJSmdr5Yqas2u9DqCidrw4gQ5cPRwxpki+8n
+s6eGKw6HGaoqYk/hsLECec5kZqy89lrn/E0+1xzlUwBXSaUsbLUKE6toHMZzoSIP
+tUIh+WoKe0gt2s4j+sMD0wSYmny0UvuFyDlyQHDOSE8TSVODGWhEr1pztqklYEfg
+oM4JrqPZAoGBAPfd9eS0qviFvRloOxPIdEeHaCc7+yBQnBWBDvgA19fcvFByJlmr
+i6qrQmChIxZS8loDGKQEPsJnrVKww15GcmDU0yesAfQHmXpplQK3cslTXhghwC3z
+p7ohMLnWjEi9Q+k0RizhFCq55w7+9U+E5wbW9017MAzC4A52mhm+GDZ/AoGBAOPH
+55TxoF4/o3rrXNtjajQ/DBYZPAmUbqpdj0QQIRkIxziiV44Aw2HmdqgtlZaQ5a/r
+8qUJCO2/on/zyQvjByx/sGfdqhOcVymySGSPOSusk6cwq2oCaDPdwZorrzueE0jV
+DgHFF9Y3p1W5CEl4Um6IWRZZS9PK4cPC/p1mXDsXAoGAVO1JTjaVChgQxb7P1yRs
+qwF7L04+6kCUak3RCiqHyh+IqmuiNkEv1qddU+yCMCj1ft/mtnP56PRLD7UfC5NJ
+p2Hkg4hNFwbvkGDSvJ6Mhuy4pb4Ssev1QTIUFuirIlUvCp1tmfz4wvb1c07qUHey
+DMbk7zhRK14uFOaQQFfAxhMCgYEAhQINY7b4mzB0COn5Dg7uTFXoe9r+aOWo/Yim
+iOsWOKUcmCCMGdquPLOz5B7CM+qmhOS1itNMyG/XtvmnE27dmIlzfCM/FjZ721hE
+15uembcrfTx5S+zd5jN+wsTxjVGQFz558GSjt65F41Op2CUPlYW+58L6+VCGJqbt
+wQGtp78CgYEA8WD+AcC70tS0h+siJoG2AYvQfBmZPGcZjGmban8SGRHcXMctpVw/
+LOP18TY4/nfT/j4OwwZ07SlCbIWPJm7+u0IiWxmf5j48pGy7p1oMxih9IggXr0+t
+KyWHrnBl8O90L7QLmSBzfOHAIoPhejgAqqADQd9lSDXSSW7GhVh0g4Q=
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/ssh_keys/vagrant_test_key.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDci17NcCLM+5r0lMqXE3kPdDdFQ1PtNdRup+DdeYQQQ4hyJ1zIACob7hdVunsWO/zQANJZOtnMk3n+t+vvrb/O+6kESYOwdxpJpajowJOd6Tq4E9EjsbAWHXvMq2Otc11morIefpJPB1xqvmGHbzaypuztMmNVWdIu4luNNkSxJVLevf8JWFZPFVBuKz9+ATshCQYIoMO0Qm1dFHdUG0PPmfkTPRp5+yNTG1yBIkosmhUms4wNU7+si9uIAQFfLe5mwWL25K9OnScjITm3wY+hB4bymByCJqE07L6wiJZxsrkFettKt1aLQ19b7YJ8kbMlejYWzT1BXOlTK2zYYCpp pivotal@holloway

data/spec/lib/ciborg/amazon_spec.rb

@@ -0,0 +1,168 @@
+require "spec_helper"
+
+describe Ciborg::Amazon, :slow do
+  subject(:amazon) { Ciborg::Amazon.new(ENV["EC2_KEY"], ENV["EC2_SECRET"]) }
+  let(:tempdir) { Dir.mktmpdir }
+  let(:fog) { amazon.send(:fog) }
+
+  before { pending "Missing EC2 Credentials" unless SpecHelpers::ec2_credentials_present? }
+
+  describe "#create_security_group" do
+    after { amazon.fog_security_groups.get(security_group).destroy if SpecHelpers::ec2_credentials_present? }
+
+    context "when there is no existing security group" do
+      let(:security_group) { "totally_not_a_honeypot" }
+
+      it "creates a security group" do
+        amazon.create_security_group(security_group)
+        amazon.fog_security_groups.map(&:name).should include security_group
+      end
+    end
+
+    context "when the security group already exists" do
+      let(:security_group) { "bart_police" }
+      before { amazon.create_security_group(security_group) }
+
+      it "does not complain" do
+        expect { amazon.create_security_group(security_group) }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#open_port" do
+    let(:security_group) { "bag_of_weasels" }
+    let(:group) { amazon.fog_security_groups.get(security_group) }
+
+    before { amazon.create_security_group(security_group) }
+    after { amazon.fog_security_groups.get(security_group).destroy if SpecHelpers::ec2_credentials_present? }
+
+    def includes_port?(permissions, port)
+      permissions.any? { |p| (p["fromPort"]..p["toPort"]).include?(port) }
+    end
+
+    it "opens a port for business" do
+      group.ip_permissions.should_not include "80"
+      amazon.open_port(security_group, 80)
+      includes_port?(group.reload.ip_permissions, 80).should be_true
+    end
+
+    it "takes a bunch of ports" do
+      amazon.open_port(security_group, 22, 443)
+      includes_port?(group.reload.ip_permissions, 22).should be_true
+      includes_port?(group.reload.ip_permissions, 443).should be_true
+    end
+  end
+
+  describe "#add_key_pair" do
+    let(:key_pair_pub) { File.read(File.expand_path(ssh_key_pair_path + ".pub")) }
+    let(:key_pair_name) { "is_supernuts" }
+
+    before { amazon.delete_key_pair(key_pair_name) }
+    after { amazon.delete_key_pair(key_pair_name) if SpecHelpers::ec2_credentials_present? }
+
+    it "uploads the key" do
+      amazon.add_key_pair(key_pair_name, key_pair_pub)
+      amazon.fog_key_pairs.map(&:name).should include key_pair_name
+    end
+
+    context "when the key is already there" do
+      before { amazon.add_key_pair(key_pair_name, key_pair_pub) }
+
+      it "doesn't reupload" do
+        expect do
+          amazon.add_key_pair(key_pair_name, key_pair_pub)
+        end.not_to raise_error
+      end
+    end
+  end
+
+  describe "things which launch instances" do
+    let(:key_pair_name) { "eating_my_cookie" }
+    let(:security_group) { "chump_of_change" }
+    let(:key_pair_pub) { File.read(File.expand_path(ssh_key_pair_path + ".pub")) }
+    let(:freshly_launched_server) { amazon.launch_server(key_pair_name, security_group, "t1.micro") }
+
+    before do
+      amazon.delete_key_pair(key_pair_name)
+      amazon.add_key_pair(key_pair_name, key_pair_pub)
+      amazon.create_security_group(security_group)
+    end
+
+    after do
+      if SpecHelpers::ec2_credentials_present?
+        freshly_launched_server.destroy
+        amazon.delete_key_pair(key_pair_name)
+        # Make a best effort attempt to clean up after the tests have completed
+        # EC2 does not always reap these resources fast enough for our tests, we could wait, but why bother?
+        amazon.elastic_ip_address.destroy rescue nil
+        amazon.fog_security_groups.get(security_group).destroy rescue nil
+      end
+    end
+
+    describe "#launch_instance" do
+      it "creates an instance" do
+        expect { freshly_launched_server }.to change { amazon.fog_servers.reload.count }.by(1)
+
+        freshly_launched_server.availability_zone.should =~ /us-east-1[abcd]/
+        freshly_launched_server.flavor_id.should == "t1.micro"
+        freshly_launched_server.tags.should == {"ciborg" => Ciborg::VERSION, "Name" => "Ciborg"}
+        freshly_launched_server.key_name.should == key_pair_name
+        freshly_launched_server.groups.should == [security_group]
+        freshly_launched_server.public_ip_address.should == amazon.elastic_ip_address.public_ip
+      end
+    end
+
+    describe "#destroy_ec2" do
+      let!(:server_ip) { freshly_launched_server.public_ip_address }
+
+      context 'with a confirmation Proc that returns true' do
+        let(:proc) { ->(_) { true } }
+
+        it "stops all the instances" do
+          # TODO: This probably needs some more testing with n > 1 instances
+          expect do
+            amazon.destroy_ec2(proc, :all)
+          end.to change { freshly_launched_server.reload.state }.from("running")
+          fog.addresses.get(server_ip).should_not be
+        end
+
+        it "stops the named instances" do
+          expect do
+            amazon.destroy_ec2(proc, freshly_launched_server.id)
+            freshly_launched_server.wait_for { !ready? }
+          end.to change { freshly_launched_server.reload.state }.from("running")
+          fog.addresses.get(server_ip).should_not be
+        end
+      end
+
+      context 'with a confirmation Proc that returns false' do
+        let(:proc) { ->(_) { false } }
+
+        it 'does not stop instances' do
+          expect do
+            amazon.destroy_ec2(proc, :all)
+          end.to_not change { freshly_launched_server.reload.state }.from("running")
+          fog.addresses.get(server_ip).should be
+        end
+      end
+    end
+  end
+
+  describe "#elastic_ip_address" do
+    it "allocates an ip address" do
+      expect { amazon.elastic_ip_address }.to change { fog.addresses.reload.count }.by(1)
+      amazon.elastic_ip_address.public_ip.should =~ /\d+\.\d+\.\d+\.\d+/
+      amazon.elastic_ip_address.destroy
+    end
+  end
+
+  describe "#release_elastic_ip" do
+    let!(:elastic_ip) { amazon.elastic_ip_address }
+
+    it "releases the ip" do
+      expect do
+        amazon.release_elastic_ip(elastic_ip.public_ip)
+      end.to change { fog.addresses.reload.count }.by(-1)
+    end
+  end
+end