bosh_aws_cpi 0.7.0 → 1.5.0.pre.1113

data/spec/integration/cpi_test.rb

@@ -1,78 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-require "tempfile"
-
-describe Bosh::AwsCloud::Cloud do
-
-  before(:each) do
-    unless ENV["CPI_CONFIG_FILE"]
-      raise "Please provide CPI_CONFIG_FILE environment variable"
-    end
-    @config = YAML.load_file(ENV["CPI_CONFIG_FILE"])
-    @logger = Logger.new(STDOUT)
-  end
-
-  let(:cpi) do
-    cpi = Bosh::AwsCloud::Cloud.new(@config)
-    cpi.logger = @logger
-
-    # As we inject the configuration file from the outside, we don't care
-    # about spinning up the registry ourselves. However we don't want to bother
-    # EC2 at all if registry is not working, so just in case we perform a test
-    # health check against whatever has been provided.
-    cpi.registry.update_settings("foo", { "bar" => "baz" })
-    cpi.registry.read_settings("foo").should == { "bar" => "baz"}
-
-    cpi
-  end
-
-  it "exercises a VM lifecycle" do
-    instance_id = cpi.create_vm(
-      "agent-007", "ami-809a48e9",
-      { "instance_type" => "m1.small" },
-      { "default" => { "type" => "dynamic" }},
-      [], { "key" => "value" })
-
-    instance_id.should_not be_nil
-
-    settings = cpi.registry.read_settings(instance_id)
-    settings["vm"].should be_a(Hash)
-    settings["vm"]["name"].should_not be_nil
-    settings["agent_id"].should == "agent-007"
-    settings["networks"].should == { "default" => { "type" => "dynamic" }}
-    settings["disks"].should == {
-      "system" => "/dev/sda",
-      "ephemeral" => "/dev/sdb",
-      "persistent" => {}
-    }
-
-    settings["env"].should == { "key" => "value" }
-
-    volume_id = cpi.create_disk(2048)
-    volume_id.should_not be_nil
-
-    cpi.attach_disk(instance_id, volume_id)
-    settings = cpi.registry.read_settings(instance_id)
-    settings["disks"]["persistent"].should == { volume_id => "/dev/sdf" }
-
-    cpi.detach_disk(instance_id, volume_id)
-    settings = cpi.registry.read_settings(instance_id)
-    settings["disks"]["persistent"].should == {}
-
-    # TODO: test configure_networks (need an elastic IP at hand for that)
-
-    cpi.delete_vm(instance_id)
-    cpi.delete_disk(volume_id)
-
-    # Test below would fail: EC2 still reports the instance as 'terminated'
-    # for some time.
-    # cpi.ec2.instances[instance_id].should be_nil
-
-    expect {
-      cpi.registry.read_settings(instance_id)
-    }.to raise_error(/HTTP 404/)
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,121 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
-
-require "rubygems"
-require "bundler"
-Bundler.setup(:default, :test)
-
-require "rspec"
-require "tmpdir"
-
-require "cloud/aws"
-
-class AwsConfig
-  attr_accessor :db, :logger, :uuid
-end
-
-aws_config = AwsConfig.new
-aws_config.db = nil # AWS CPI doesn't need DB
-aws_config.logger = Logger.new(StringIO.new)
-aws_config.logger.level = Logger::DEBUG
-
-Bosh::Clouds::Config.configure(aws_config)
-
-MOCK_AWS_ACCESS_KEY_ID = "foo"
-MOCK_AWS_SECRET_ACCESS_KEY = "bar"
-
-def internal_to(*args, &block)
-  example = describe *args, &block
-  klass = args[0]
-  if klass.is_a? Class
-    saved_private_instance_methods = klass.private_instance_methods
-    example.before do
-      klass.class_eval { public *saved_private_instance_methods }
-    end
-    example.after do
-      klass.class_eval { private *saved_private_instance_methods }
-    end
-  end
-end
-
-def mock_cloud_options
-  {
-    "aws" => {
-      "access_key_id" => MOCK_AWS_ACCESS_KEY_ID,
-      "secret_access_key" => MOCK_AWS_SECRET_ACCESS_KEY
-    },
-    "registry" => {
-      "endpoint" => "localhost:42288",
-      "user" => "admin",
-      "password" => "admin"
-    },
-    "agent" => {
-      "foo" => "bar",
-      "baz" => "zaz"
-    }
-  }
-end
-
-def make_cloud(options = nil)
-  Bosh::AwsCloud::Cloud.new(options || mock_cloud_options)
-end
-
-def mock_registry(endpoint = "http://registry:3333")
-  registry = mock("registry", :endpoint => endpoint)
-  Bosh::AwsCloud::RegistryClient.stub!(:new).and_return(registry)
-  registry
-end
-
-def mock_cloud(options = nil)
-  ec2 = mock_ec2
-  AWS::EC2.stub(:new).and_return(ec2)
-
-  yield ec2 if block_given?
-
-  Bosh::AwsCloud::Cloud.new(options || mock_cloud_options)
-end
-
-def mock_ec2
-  ec2 = double(AWS::EC2,
-               :instances => double("instances"),
-               :volumes => double("volumes"),
-               :images =>double("images"))
-
-  yield ec2 if block_given?
-
-  ec2
-end
-
-def dynamic_network_spec
-  {
-      "type" => "dynamic",
-      "cloud_properties" => {
-          "security_groups" => %w[default]
-      }
-  }
-end
-
-def vip_network_spec
-  {
-    "type" => "vip",
-    "ip" => "10.0.0.1"
-  }
-end
-
-def combined_network_spec
-  {
-    "network_a" => dynamic_network_spec,
-    "network_b" => vip_network_spec
-  }
-end
-
-def resource_pool_spec
-  {
-    "key_name" => "test_key",
-    "availability_zone" => "foobar-1a",
-    "instance_type" => "m3.zb"
-  }
-end
-
-

data/spec/unit/aki_picker_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe Bosh::AwsCloud::AKIPicker do
-  let(:akis) {
-    [
-      double("image-1", :root_device_name => "/dev/sda1",
-             :image_location => "pv-grub-hd00_1.03-x86_64.gz",
-             :image_id => "aki-b4aa75dd"),
-      double("image-2", :root_device_name => "/dev/sda1",
-             :image_location => "pv-grub-hd00_1.02-x86_64.gz",
-             :image_id => "aki-b4aa75d0")
-    ]
-  }
-  let(:logger) {double("logger", :info => nil)}
-  let(:picker) {Bosh::AwsCloud::AKIPicker.new(double("ec2"))}
-
-  it "should pick the AKI with the highest version" do
-    picker.should_receive(:logger).and_return(logger)
-    picker.should_receive(:fetch_akis).and_return(akis)
-    picker.pick("x86_64", "/dev/sda1").should == "aki-b4aa75dd"
-  end
-
-  it "should raise an error when it can't pick an AKI" do
-    picker.should_receive(:fetch_akis).and_return(akis)
-    expect {
-      picker.pick("foo", "bar")
-    }.to raise_error Bosh::Clouds::CloudError, "unable to find AKI"
-  end
-end

data/spec/unit/attach_disk_spec.rb

@@ -1,143 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-describe Bosh::AwsCloud::Cloud do
-
-  before(:each) do
-    @registry = mock_registry
-  end
-
-  it "attaches EC2 volume to an instance" do
-    instance = double("instance", :id => "i-test")
-    volume = double("volume", :id => "v-foobar")
-    attachment = double("attachment", :device => "/dev/sdf")
-
-    cloud = mock_cloud do |ec2|
-      ec2.instances.should_receive(:[]).with("i-test").and_return(instance)
-      ec2.volumes.should_receive(:[]).with("v-foobar").and_return(volume)
-    end
-
-    volume.should_receive(:attach_to).
-      with(instance, "/dev/sdf").and_return(attachment)
-
-    instance.should_receive(:block_device_mappings).and_return({})
-
-    cloud.should_receive(:wait_resource).with(attachment, :attached)
-
-    old_settings = { "foo" => "bar" }
-    new_settings = {
-      "foo" => "bar",
-      "disks" => {
-        "persistent" => {
-          "v-foobar" => "/dev/sdf"
-        }
-      }
-    }
-
-    @registry.should_receive(:read_settings).
-      with("i-test").
-      and_return(old_settings)
-
-    @registry.should_receive(:update_settings).with("i-test", new_settings)
-
-    cloud.attach_disk("i-test", "v-foobar")
-  end
-
-  it "picks available device name" do
-    instance = double("instance", :id => "i-test")
-    volume = double("volume", :id => "v-foobar")
-    attachment = double("attachment", :device => "/dev/sdh")
-
-    cloud = mock_cloud do |ec2|
-      ec2.instances.should_receive(:[]).with("i-test").and_return(instance)
-      ec2.volumes.should_receive(:[]).with("v-foobar").and_return(volume)
-    end
-
-    instance.should_receive(:block_device_mappings).
-      and_return({ "/dev/sdf" => "foo", "/dev/sdg" => "bar" })
-
-    volume.should_receive(:attach_to).
-      with(instance, "/dev/sdh").and_return(attachment)
-
-    cloud.should_receive(:wait_resource).with(attachment, :attached)
-
-    old_settings = { "foo" => "bar" }
-    new_settings = {
-      "foo" => "bar",
-      "disks" => {
-        "persistent" => {
-          "v-foobar" => "/dev/sdh"
-        }
-      }
-    }
-
-    @registry.should_receive(:read_settings).
-      with("i-test").
-      and_return(old_settings)
-
-    @registry.should_receive(:update_settings).with("i-test", new_settings)
-
-    cloud.attach_disk("i-test", "v-foobar")
-  end
-
-  it "picks available device name" do
-    instance = double("instance", :id => "i-test")
-    volume = double("volume", :id => "v-foobar")
-    attachment = double("attachment", :device => "/dev/sdh")
-
-    cloud = mock_cloud do |ec2|
-      ec2.instances.should_receive(:[]).with("i-test").and_return(instance)
-      ec2.volumes.should_receive(:[]).with("v-foobar").and_return(volume)
-    end
-
-    instance.should_receive(:block_device_mappings).
-      and_return({ "/dev/sdf" => "foo", "/dev/sdg" => "bar" })
-
-    volume.should_receive(:attach_to).
-      with(instance, "/dev/sdh").and_return(attachment)
-
-    cloud.should_receive(:wait_resource).with(attachment, :attached)
-
-    old_settings = { "foo" => "bar" }
-    new_settings = {
-      "foo" => "bar",
-      "disks" => {
-        "persistent" => {
-          "v-foobar" => "/dev/sdh"
-        }
-      }
-    }
-
-    @registry.should_receive(:read_settings).
-      with("i-test").
-      and_return(old_settings)
-
-    @registry.should_receive(:update_settings).with("i-test", new_settings)
-
-    cloud.attach_disk("i-test", "v-foobar")
-  end
-
-  it "raises an error when sdf..sdp are all reserved" do
-    instance = double("instance", :id => "i-test")
-    volume = double("volume", :id => "v-foobar")
-
-    cloud = mock_cloud do |ec2|
-      ec2.instances.should_receive(:[]).with("i-test").and_return(instance)
-      ec2.volumes.should_receive(:[]).with("v-foobar").and_return(volume)
-    end
-
-    all_mappings = ("f".."p").inject({}) do |hash, char|
-      hash["/dev/sd#{char}"] = "foo"
-      hash
-    end
-
-    instance.should_receive(:block_device_mappings).
-      and_return(all_mappings)
-
-    expect {
-      cloud.attach_disk("i-test", "v-foobar")
-    }.to raise_error(Bosh::Clouds::CloudError, /too many disks attached/)
-  end
-
-end

data/spec/unit/cloud_spec.rb

@@ -1,32 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-describe Bosh::AwsCloud::Cloud do
-
-  describe "creating via provider" do
-
-    it "can be created using Bosh::Cloud::Provider" do
-      cloud = Bosh::Clouds::Provider.create(:aws, mock_cloud_options)
-      cloud.should be_an_instance_of(Bosh::AwsCloud::Cloud)
-    end
-
-  end
-
-  internal_to Bosh::AwsCloud::Cloud do
-
-    it "should not find stemcell-copy" do
-      cloud = Bosh::Clouds::Provider.create(:aws, mock_cloud_options)
-      cloud.has_stemcell_copy("/usr/bin:/usr/sbin").should be_nil
-    end
-
-    it "should find stemcell-copy" do
-      cloud = Bosh::Clouds::Provider.create(:aws, mock_cloud_options)
-      path = ENV["PATH"]
-      path += ":#{File.expand_path('../../assets', __FILE__)}"
-      cloud.has_stemcell_copy(path).should_not be_nil
-    end
-
-  end
-
-end

data/spec/unit/configure_networks_spec.rb

@@ -1,113 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-describe Bosh::AwsCloud::Cloud do
-
-  before(:each) do
-    @registry = mock_registry
-  end
-
-  it "forces recreation when security groups differ" do
-    sec_grp = double("security_group", :name => "newgroup")
-    instance = double("instance",
-                      :id => "i-foobar",
-                      :security_groups => [sec_grp])
-
-    cloud = mock_cloud do |ec2|
-      ec2.instances.stub(:[]).
-          with("i-foobar").
-          and_return(instance)
-    end
-
-    lambda {
-      cloud.configure_networks("i-foobar", combined_network_spec)
-    }.should raise_error Bosh::Clouds::NotSupported
-  end
-
-  it "adds elastic ip from to the instance for vip network" do
-    sec_grp = double("security_group", :name => "default")
-    instance = double("instance",
-                      :id => "i-foobar",
-                      :security_groups => [sec_grp])
-
-    cloud = mock_cloud do |ec2|
-      ec2.instances.stub(:[]).
-        with("i-foobar").
-        and_return(instance)
-    end
-
-    old_settings = { "foo" => "bar", "networks" => "baz" }
-    new_settings = { "foo" => "bar", "networks" => combined_network_spec }
-
-    @registry.should_receive(:read_settings).
-      with("i-foobar").
-      and_return(old_settings)
-
-    @registry.should_receive(:update_settings).with("i-foobar", new_settings)
-
-    instance.should_receive(:associate_elastic_ip).with("10.0.0.1")
-
-    cloud.configure_networks("i-foobar", combined_network_spec)
-  end
-
-  it "removes elastic ip from the instance if vip network is gone" do
-    sec_grp = double("security_group", :name => "default")
-    instance = double("instance",
-                      :id => "i-foobar",
-                      :security_groups => [sec_grp])
-
-    cloud = mock_cloud do |ec2|
-      ec2.instances.stub(:[]).
-        with("i-foobar").
-        and_return(instance)
-    end
-
-    instance.should_receive(:elastic_ip).and_return("10.0.0.1")
-    instance.should_receive(:disassociate_elastic_ip)
-
-    old_settings = { "foo" => "bar", "networks" => combined_network_spec }
-    new_settings = {
-      "foo" => "bar",
-      "networks" => {
-        "net_a" => dynamic_network_spec
-      }
-    }
-
-    @registry.should_receive(:read_settings).
-      with("i-foobar").
-      and_return(old_settings)
-
-    @registry.should_receive(:update_settings).with("i-foobar", new_settings)
-
-    cloud.configure_networks("i-foobar", "net_a" => dynamic_network_spec)
-  end
-
-  it "performs network sanity check" do
-    expect {
-      mock_cloud.configure_networks("i-foobar", "net_a" => vip_network_spec)
-    }.to raise_error(Bosh::Clouds::CloudError,
-                     "At least one dynamic network should be defined")
-
-    expect {
-      mock_cloud.configure_networks("i-foobar",
-                                    "net_a" => vip_network_spec,
-                                    "net_b" => vip_network_spec)
-    }.to raise_error(Bosh::Clouds::CloudError,
-                     /More than one vip network/)
-
-    expect {
-      mock_cloud.configure_networks("i-foobar",
-                                    "net_a" => dynamic_network_spec,
-                                    "net_b" => dynamic_network_spec)
-    }.to raise_error(Bosh::Clouds::CloudError,
-                     /More than one dynamic network/)
-
-    expect {
-      mock_cloud.configure_networks("i-foobar",
-                                    "net_a" => { "type" => "foo" })
-    }.to raise_error(Bosh::Clouds::CloudError,
-                     /Invalid network type `foo'/)
-  end
-
-end

data/spec/unit/create_disk_spec.rb

@@ -1,73 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-describe Bosh::AwsCloud::Cloud do
-
-  it "creates an EC2 volume" do
-    disk_params = {
-      :size => 2,
-      :availability_zone => "us-east-1a"
-    }
-
-    volume = double("volume", :id => "v-foobar")
-
-    cloud = mock_cloud do |ec2|
-      ec2.volumes.should_receive(:create).with(disk_params).and_return(volume)
-    end
-
-    cloud.should_receive(:wait_resource).with(volume, :available)
-
-    cloud.create_disk(2048).should == "v-foobar"
-  end
-
-  it "rounds up disk size" do
-    disk_params = {
-      :size => 3,
-      :availability_zone => "us-east-1a"
-    }
-
-    volume = double("volume", :id => "v-foobar")
-
-    cloud = mock_cloud do |ec2|
-      ec2.volumes.should_receive(:create).with(disk_params).and_return(volume)
-    end
-
-    cloud.should_receive(:wait_resource).with(volume, :available)
-
-    cloud.create_disk(2049)
-  end
-
-  it "check min and max disk size" do
-    expect {
-      mock_cloud.create_disk(100)
-    }.to raise_error(Bosh::Clouds::CloudError, /minimum disk size is 1 GiB/)
-
-    expect {
-      mock_cloud.create_disk(2000 * 1024)
-    }.to raise_error(Bosh::Clouds::CloudError, /maximum disk size is 1 TiB/)
-  end
-
-  it "puts disk in the same AZ as an instance" do
-    disk_params = {
-      :size => 1,
-      :availability_zone => "foobar-land"
-    }
-
-    instance = double("instance",
-                      :id => "i-test",
-                      :availability_zone => "foobar-land")
-
-    volume = double("volume", :id => "v-foobar")
-
-    cloud = mock_cloud do |ec2|
-      ec2.volumes.should_receive(:create).with(disk_params).and_return(volume)
-      ec2.instances.stub(:[]).with("i-test").and_return(instance)
-    end
-
-    cloud.should_receive(:wait_resource).with(volume, :available)
-
-    cloud.create_disk(1024, "i-test")
-  end
-
-end