bosh_openstack_cpi 0.0.2

data/spec/unit/attach_disk_spec.rb

@@ -0,0 +1,95 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::OpenStackCloud::Cloud do
+
+  before(:each) do
+    @registry = mock_registry
+  end
+
+  it "attaches an OpenStack volume to a server" do
+    server = double("server", :id => "i-test", :name => "i-test")
+    volume = double("volume", :id => "v-foobar")
+    volume_attachments = double("body", :body => {"volumeAttachments" => []})
+    attachment = double("attachment", :device => "/dev/vdc")
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      openstack.volumes.should_receive(:get).with("v-foobar").and_return(volume)
+      openstack.should_receive(:get_server_volumes).and_return(volume_attachments)
+    end
+
+    volume.should_receive(:attach).with(server.id, "/dev/vdc").and_return(attachment)
+    volume.should_receive(:status).and_return(:available)
+    cloud.should_receive(:wait_resource).with(volume, :available, :"in-use")
+
+    old_settings = { "foo" => "bar" }
+    new_settings = {
+      "foo" => "bar",
+      "disks" => {
+        "persistent" => {
+          "v-foobar" => "/dev/vdc"
+        }
+      }
+    }
+
+    @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
+    server = double("server", :id => "i-test", :name => "i-test")
+    volume = double("volume", :id => "v-foobar")
+    volume_attachments = double("body", :body => {"volumeAttachments" => [{"device" => "/dev/vdc"}, {"device" => "/dev/vdd"}]})
+    attachment = double("attachment", :device => "/dev/vdd")
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      openstack.volumes.should_receive(:get).with("v-foobar").and_return(volume)
+      openstack.should_receive(:get_server_volumes).and_return(volume_attachments)
+    end
+
+    volume.should_receive(:attach).with(server.id, "/dev/vde").and_return(attachment)
+    volume.should_receive(:status).and_return(:available)
+    cloud.should_receive(:wait_resource).with(volume, :available, :"in-use")
+
+    old_settings = { "foo" => "bar" }
+    new_settings = {
+      "foo" => "bar",
+      "disks" => {
+        "persistent" => {
+          "v-foobar" => "/dev/vde"
+        }
+      }
+    }
+
+    @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 vdc..vdz are all reserved" do
+    server = double("server", :id => "i-test", :name => "i-test")
+    volume = double("volume", :id => "v-foobar")
+    all_mappings = ("c".."z").inject([]) do |array, char|
+      array << {"device" => "/dev/vd#{char}"}
+      array
+    end
+    volume_attachments = double("body", :body => {"volumeAttachments" => all_mappings})
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      openstack.volumes.should_receive(:get).with("v-foobar").and_return(volume)
+      openstack.should_receive(:get_server_volumes).and_return(volume_attachments)
+    end
+
+    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,18 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::OpenStackCloud::Cloud do
+
+  describe "creating via provider" do
+
+    it "can be created using Bosh::Cloud::Provider" do
+      Fog::Compute.stub(:new)
+      Fog::Image.stub(:new)
+      cloud = Bosh::Clouds::Provider.create(:openstack, mock_cloud_options)
+      cloud.should be_an_instance_of(Bosh::OpenStackCloud::Cloud)
+    end
+
+  end
+
+end

data/spec/unit/configure_networks_spec.rb

@@ -0,0 +1,83 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::OpenStackCloud::Cloud do
+
+  before(:each) do
+    @registry = mock_registry
+  end
+
+  it "adds floating ip to the server for vip network" do
+    server = double("server", :id => "i-test", :name => "i-test")
+    address = double("address", :id => "a-test", :ip => "10.0.0.1", :instance_id => nil)
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      openstack.addresses.should_receive(:each).and_yield(address)
+    end
+
+    address.should_receive(:server=).with(server)
+
+    old_settings = { "foo" => "bar", "networks" => "baz" }
+    new_settings = { "foo" => "bar", "networks" => combined_network_spec }
+
+    @registry.should_receive(:read_settings).with("i-test").and_return(old_settings)
+    @registry.should_receive(:update_settings).with("i-test", new_settings)
+
+    cloud.configure_networks("i-test", combined_network_spec)
+  end
+
+  it "removes floating ip from the server if vip network is gone" do
+    server = double("server", :id => "i-test", :name => "i-test")
+    address = double("address", :id => "a-test", :ip => "10.0.0.1", :instance_id => "i-test")
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      openstack.addresses.should_receive(:each).and_yield(address)
+    end
+
+    address.should_receive(:server=).with(nil)
+
+    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-test").and_return(old_settings)
+    @registry.should_receive(:update_settings).with("i-test", new_settings)
+
+    cloud.configure_networks("i-test", "net_a" => dynamic_network_spec)
+  end
+
+  it "performs network sanity check" do
+    server = double("server", :id => "i-test", :name => "i-test")
+
+    expect {
+      cloud = mock_cloud do |openstack|
+        openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      end
+      cloud.configure_networks("i-test", "net_a" => vip_network_spec)
+    }.to raise_error(Bosh::Clouds::CloudError, "At least one dynamic network should be defined")
+
+    expect {
+      cloud = mock_cloud do |openstack|
+        openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      end
+      cloud.configure_networks("i-test", "net_a" => vip_network_spec, "net_b" => vip_network_spec)
+    }.to raise_error(Bosh::Clouds::CloudError, /More than one vip network/)
+
+    expect {
+      cloud = mock_cloud do |openstack|
+        openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      end
+      cloud.configure_networks("i-test", "net_a" => dynamic_network_spec, "net_b" => dynamic_network_spec)
+    }.to raise_error(Bosh::Clouds::CloudError, /More than one dynamic network/)
+
+    expect {
+      cloud = mock_cloud do |openstack|
+        openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      end
+      cloud.configure_networks("i-test", "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,82 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::OpenStackCloud::Cloud do
+
+  it "creates an OpenStack volume" do
+    unique_name = UUIDTools::UUID.random_create.to_s
+    disk_params = {
+      :name => "volume-#{unique_name}",
+      :description => "",
+      :size => 2,
+      :availability_zone => "nova"
+    }
+    volume = double("volume", :id => "v-foobar")
+
+    cloud = mock_cloud do |openstack|
+      openstack.volumes.should_receive(:create).with(disk_params).and_return(volume)
+    end
+
+    cloud.should_receive(:generate_unique_name).and_return(unique_name)
+    volume.should_receive(:status).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
+    unique_name = UUIDTools::UUID.random_create.to_s
+    disk_params = {
+      :name => "volume-#{unique_name}",
+      :description => "",
+      :size => 3,
+      :availability_zone => "nova"
+    }
+    volume = double("volume", :id => "v-foobar")
+
+    cloud = mock_cloud do |openstack|
+      openstack.volumes.should_receive(:create).with(disk_params).and_return(volume)
+    end
+
+    cloud.should_receive(:generate_unique_name).and_return(unique_name)
+    volume.should_receive(:status).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 a server" do
+    unique_name = UUIDTools::UUID.random_create.to_s
+    disk_params = {
+      :name => "volume-#{unique_name}",
+      :description => "",
+      :size => 1,
+      :availability_zone => "foobar-land"
+    }
+    server = double("server", :id => "i-test", :availability_zone => "foobar-land")
+    volume = double("volume", :id => "v-foobar")
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:get).with("i-test").and_return(server)
+      openstack.volumes.should_receive(:create).with(disk_params).and_return(volume)
+    end
+
+    cloud.should_receive(:generate_unique_name).and_return(unique_name)
+    volume.should_receive(:status).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,50 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::OpenStackCloud::Cloud do
+
+  before :each do
+    @tmp_dir = Dir.mktmpdir
+  end
+
+  describe "Image upload based flow" do
+
+    it "creates stemcell by uploading an image via Glance" do
+      image = double("image", :id => "i-bar", :name => "i-bar")
+      unique_name = UUIDTools::UUID.random_create.to_s
+      image_params = {
+        :name => "BOSH-#{unique_name}",
+        :disk_format => "ami",
+        :container_format => "ami",
+        :location => "#{@tmp_dir}/root.img",
+        :is_public => true,
+        :properties => {
+          :kernel_id => "k-id",
+          :ramdisk_id => "r-id",
+        }
+      }
+
+      cloud = mock_glance do |glance|
+        glance.images.should_receive(:create).with(image_params).and_return(image)
+      end
+
+      Dir.should_receive(:mktmpdir).and_yield(@tmp_dir)
+      cloud.should_receive(:unpack_image).with(@tmp_dir, "/tmp/foo")
+      cloud.should_receive(:generate_unique_name).and_return(unique_name)
+      image.should_receive(:status).and_return(:queued)
+      cloud.should_receive(:wait_resource).with(image, :queued, :active)
+
+      sc_id = cloud.create_stemcell("/tmp/foo", {
+        "container_format" => "ami",
+        "disk_format" => "ami",
+        "kernel_id" => "k-id",
+        "ramdisk_id" => "r-id"
+      })
+
+      sc_id.should == "i-bar"
+    end
+
+  end
+
+end

data/spec/unit/create_vm_spec.rb

@@ -0,0 +1,142 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::OpenStackCloud::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/vda",
+        "ephemeral" => "/dev/vdb",
+        "persistent" => {}
+      },
+      "env" => {
+        "test_env" => "value"
+      },
+      "foo" => "bar", # Agent env
+      "baz" => "zaz"
+    }
+  end
+
+  def openstack_params(unique_name, user_data, security_groups=[])
+    {
+      :name=>"vm-#{unique_name}",
+      :image_ref => "sc-id",
+      :flavor_ref => "f-test",
+      :key_name => "test_key",
+      :security_groups => security_groups.map { |secgrp| {:name => secgrp} },
+      :user_data => Yajl::Encoder.encode(user_data),
+      :availability_zone => "foobar-1a"
+    }
+  end
+
+  before(:each) do
+    @registry = mock_registry
+  end
+
+  it "creates an OpenStack server and polls until it's ready" do
+    unique_name = UUIDTools::UUID.random_create.to_s
+    user_data = {
+      "registry" => {
+        "endpoint" => "http://registry:3333"
+      },
+      "server" => {
+        "name" => "vm-#{unique_name}"
+      }
+    }
+    server = double("server", :id => "i-test", :name => "i-test")
+    image = double("image", :id => "sc-id", :name => "sc-id")
+    flavor = double("flavor", :id => "f-test", :name => "m1.tiny")
+    address = double("address", :id => "a-test", :ip => "10.0.0.1", :instance_id => "i-test")
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:create).with(openstack_params(unique_name, user_data)).and_return(server)
+      openstack.images.should_receive(:find).and_return(image)
+      openstack.flavors.should_receive(:find).and_return(flavor)
+      openstack.addresses.should_receive(:each).and_yield(address)
+    end
+
+    cloud.should_receive(:generate_unique_name).and_return(unique_name)
+    address.should_receive(:server=).with(nil)
+    server.should_receive(:state).and_return(:build)
+    cloud.should_receive(:wait_resource).with(server, :build, :active, :state)
+
+    @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 an OpenStack server with security group" do
+    unique_name = UUIDTools::UUID.random_create.to_s
+    user_data = {
+      "registry" => {
+        "endpoint" => "http://registry:3333"
+      },
+      "server" => {
+        "name" => "vm-#{unique_name}"
+      }
+    }
+    security_groups = %w[foo bar]
+    network_spec = dynamic_network_spec
+    network_spec["cloud_properties"] = { "security_groups" => security_groups }
+    server = double("server", :id => "i-test", :name => "i-test")
+    image = double("image", :id => "sc-id", :name => "sc-id")
+    flavor = double("flavor", :id => "f-test", :name => "m1.tiny")
+    address = double("address", :id => "a-test", :ip => "10.0.0.1", :instance_id => nil)
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:create).with(openstack_params(unique_name, user_data, security_groups)).and_return(server)
+      openstack.images.should_receive(:find).and_return(image)
+      openstack.flavors.should_receive(:find).and_return(flavor)
+      openstack.addresses.should_receive(:each).and_yield(address)
+    end
+
+    cloud.should_receive(:generate_unique_name).and_return(unique_name)
+    server.should_receive(:state).and_return(:build)
+    cloud.should_receive(:wait_resource).with(server, :build, :active, :state)
+
+    @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 server with floating ip if vip network is provided" do
+    server = double("server", :id => "i-test", :name => "i-test")
+    image = double("image", :id => "sc-id", :name => "sc-id")
+    flavor = double("flavor", :id => "f-test", :name => "m1.tiny")
+    address = double("address", :id => "a-test", :ip => "10.0.0.1", :instance_id => "i-test")
+
+    cloud = mock_cloud do |openstack|
+      openstack.servers.should_receive(:create).and_return(server)
+      openstack.images.should_receive(:find).and_return(image)
+      openstack.flavors.should_receive(:find).and_return(flavor)
+      openstack.addresses.should_receive(:each).and_yield(address)
+    end
+
+    address.should_receive(:server=).with(nil)
+    address.should_receive(:server=).with(server)
+    server.should_receive(:state).and_return(:build)
+    cloud.should_receive(:wait_resource).with(server, :build, :active, :state)
+
+    @registry.should_receive(:update_settings)
+
+    vm_id = cloud.create_vm("agent-id", "sc-id",
+                            resource_pool_spec,
+                            combined_network_spec)
+  end
+
+end