bosh_aws_cpi 0.3.3

data/spec/unit/attach_disk_spec.rb

@@ -0,0 +1,146 @@
+# 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({})
+
+    attachment.should_receive(:status).and_return(:attaching)
+    cloud.should_receive(:wait_resource).with(attachment, :attaching, :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)
+
+    attachment.should_receive(:status).and_return(:attaching)
+    cloud.should_receive(:wait_resource).with(attachment, :attaching, :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)
+
+    attachment.should_receive(:status).and_return(:attaching)
+    cloud.should_receive(:wait_resource).with(attachment, :attaching, :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

@@ -0,0 +1,16 @@
+# 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
+
+end

data/spec/unit/configure_networks_spec.rb

@@ -0,0 +1,92 @@
+# 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 "adds elastic ip from to the instance for vip network" do
+    instance = double("instance",
+                      :id => "i-foobar")
+
+    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
+    instance = double("instance",
+                      :id => "i-foobar")
+
+    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

@@ -0,0 +1,76 @@
+# 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
+
+    volume.should_receive(:state).and_return(:creating)
+    cloud.should_receive(:wait_resource).with(volume, :creating, :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
+
+    volume.should_receive(:state).and_return(:creating)
+    cloud.should_receive(:wait_resource).with(volume, :creating, :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
+
+    volume.should_receive(:state).and_return(:creating)
+    cloud.should_receive(:wait_resource).with(volume, :creating, :available)
+
+    cloud.create_disk(1024, "i-test")
+  end
+
+end

data/spec/unit/create_stemcell_spec.rb

@@ -0,0 +1,107 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::AwsCloud::Cloud do
+
+  before :each do
+    @tmp_dir = Dir.mktmpdir
+  end
+
+  describe "EBS-volume based flow" do
+
+    it "creates stemcell by copying an image to a new EBS volume" do
+      volume = double("volume", :id => "v-foo")
+      current_instance = double("instance",
+                                :id => "i-current",
+                                :availability_zone => "us-nowhere-2b")
+      attachment = double("attachment",
+                          :device => "/dev/sdh",
+                          :volume => volume)
+
+      snapshot = double("snapshot", :id => "s-baz")
+      image = double("image", :id => "i-bar")
+
+      unique_name = UUIDTools::UUID.random_create.to_s
+
+      image_params = {
+        :name => "BOSH-#{unique_name}",
+        :architecture => "x86_64",
+        :kernel_id => "aki-825ea7eb",
+        :root_device_name => "/dev/sda",
+        :block_device_mappings => {
+          "/dev/sda" => { :snapshot_id => "s-baz" },
+          "/dev/sdb" => "ephemeral0"
+        }
+      }
+
+      cloud = mock_cloud do |ec2|
+        ec2.volumes.stub(:[]).with("v-foo").and_return(volume)
+        ec2.instances.stub(:[]).with("i-current").and_return(current_instance)
+        ec2.images.should_receive(:create).with(image_params).and_return(image)
+      end
+
+      cloud.stub(:generate_unique_name).and_return(unique_name)
+      cloud.stub(:current_instance_id).and_return("i-current")
+
+      old_mappings = {
+        "/dev/sdf" => double("attachment",
+                             :volume => double("volume",
+                                               :id => "v-zb")),
+        "/dev/sdg" => double("attachment",
+                             :volume => double("volume",
+                                               :id => "v-ppc"))
+      }
+
+      extra_mapping = {
+        "/dev/sdh" => attachment
+      }
+
+      new_mappings = old_mappings.merge(extra_mapping)
+
+      current_instance.stub(:block_device_mappings).
+        and_return(old_mappings, new_mappings)
+
+      cloud.should_receive(:create_disk).with(2048, "i-current").
+        and_return("v-foo")
+
+      volume.should_receive(:attach_to).with(current_instance, "/dev/sdh").
+        and_return(attachment)
+
+      attachment.should_receive(:status).and_return(:attaching)
+      cloud.should_receive(:wait_resource).
+        with(attachment, :attaching, :attached)
+
+      cloud.stub(:sleep)
+
+      File.stub(:blockdev?).with("/dev/sdh").and_return(false, false, false)
+      File.stub(:blockdev?).with("/dev/xvdh").and_return(false, false, true)
+
+      Dir.should_receive(:mktmpdir).and_yield(@tmp_dir)
+
+      cloud.should_receive(:unpack_image).with(@tmp_dir, "/tmp/foo")
+      cloud.should_receive(:copy_root_image).with(@tmp_dir, "/dev/xvdh")
+
+      volume.should_receive(:create_snapshot).and_return(snapshot)
+      snapshot.should_receive(:status).and_return(:in_progress)
+      cloud.should_receive(:wait_resource).
+        with(snapshot, :in_progress, :completed)
+
+      image.should_receive(:state).and_return(:creating)
+      cloud.should_receive(:wait_resource).with(image,
+                                                :creating, :available, :state)
+
+      volume.should_receive(:detach_from).with(current_instance, "/dev/sdh").
+        and_return(attachment)
+
+      attachment.should_receive(:status).and_return(:detaching)
+      cloud.should_receive(:wait_resource).
+        with(attachment, :detaching, :detached)
+
+      cloud.should_receive(:delete_disk).with("v-foo")
+
+      cloud.create_stemcell("/tmp/foo", {}).should == "i-bar"
+    end
+
+  end
+end

data/spec/unit/create_vm_spec.rb

@@ -0,0 +1,134 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::AwsCloud::Cloud, "create_vm" do
+
+  def agent_settings(unique_name, network_spec=dynamic_network_spec)
+    {
+      "vm" => {
+        "name" => "vm-#{unique_name}"
+      },
+      "agent_id" => "agent-id",
+      "networks" => { "network_a" => network_spec },
+      "disks" => {
+        "system" => "/dev/sda",
+        "ephemeral" => "/dev/sdb",
+        "persistent" => {}
+      },
+      "env" => {
+        "test_env" => "value"
+      },
+      "foo" => "bar", # Agent env
+      "baz" => "zaz"
+    }
+  end
+
+  def ec2_params(user_data, security_groups=[])
+    {
+      :image_id => "sc-id",
+      :count => 1,
+      :key_name => "test_key",
+      :security_groups => security_groups,
+      :instance_type => "m3.zb",
+      :user_data => Yajl::Encoder.encode(user_data),
+      :availability_zone => "foobar-1a"
+    }
+  end
+
+  before(:each) do
+    @registry = mock_registry
+  end
+
+  it "creates EC2 instance and polls until it's ready" do
+    unique_name = UUIDTools::UUID.random_create.to_s
+
+    user_data = {
+      "registry" => {
+        "endpoint" => "http://registry:3333"
+      }
+    }
+
+    instance = double("instance",
+                      :id => "i-test",
+                      :elastic_ip => nil)
+
+    cloud = mock_cloud do |ec2|
+      ec2.instances.should_receive(:create).
+        with(ec2_params(user_data)).
+        and_return(instance)
+    end
+
+    instance.should_receive(:status).and_return(:pending)
+    cloud.should_receive(:generate_unique_name).and_return(unique_name)
+    cloud.should_receive(:wait_resource).with(instance, :pending, :running)
+    @registry.should_receive(:update_settings)
+      .with("i-test", agent_settings(unique_name))
+
+    vm_id = cloud.create_vm("agent-id", "sc-id",
+                            resource_pool_spec,
+                            { "network_a" => dynamic_network_spec },
+                            nil, { "test_env" => "value" })
+
+    vm_id.should == "i-test"
+  end
+
+  it "creates EC2 instance with security group" do
+    unique_name = UUIDTools::UUID.random_create.to_s
+
+    user_data = {
+      "registry" => {
+        "endpoint" => "http://registry:3333"
+      }
+    }
+
+    instance = double("instance",
+                      :id => "i-test",
+                      :elastic_ip => nil)
+
+    security_groups = %w[foo bar]
+    network_spec = dynamic_network_spec
+    network_spec["cloud_properties"] = {
+      "security_groups" => security_groups
+    }
+
+    cloud = mock_cloud do |ec2|
+      ec2.instances.should_receive(:create).
+        with(ec2_params(user_data, security_groups)).
+        and_return(instance)
+    end
+
+    instance.should_receive(:status).and_return(:pending)
+    cloud.should_receive(:generate_unique_name).and_return(unique_name)
+    cloud.should_receive(:wait_resource).with(instance, :pending, :running)
+    @registry.should_receive(:update_settings)
+      .with("i-test", agent_settings(unique_name, network_spec))
+
+    vm_id = cloud.create_vm("agent-id", "sc-id",
+                            resource_pool_spec,
+                            { "network_a" => network_spec },
+                            nil, { "test_env" => "value" })
+
+    vm_id.should == "i-test"
+  end
+
+  it "associates instance with elastic ip if vip network is provided" do
+    instance = double("instance",
+                      :id => "i-test",
+                      :elastic_ip => nil)
+
+    cloud = mock_cloud do |ec2|
+      ec2.instances.should_receive(:create).and_return(instance)
+    end
+
+    instance.should_receive(:status).and_return(:pending)
+    instance.should_receive(:associate_elastic_ip).with("10.0.0.1")
+    cloud.should_receive(:wait_resource).with(instance, :pending, :running)
+    @registry.should_receive(:update_settings)
+
+    vm_id = cloud.create_vm("agent-id", "sc-id",
+                            resource_pool_spec,
+                            combined_network_spec)
+  end
+
+end