bosh_openstack_cpi 0.0.7 → 1.5.0.pre.1113

data/spec/unit/create_disk_spec.rb

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

data/spec/unit/create_stemcell_spec.rb

@@ -1,315 +0,0 @@
-# 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 using an image without kernel nor ramdisk" 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
-      }
-
-      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)
-
-      sc_id = cloud.create_stemcell("/tmp/foo", {
-        "container_format" => "ami",
-        "disk_format" => "ami"
-      })
-
-      sc_id.should == "i-bar"
-    end
-
-    it "creates stemcell using an image with kernel and ramdisk id's" 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)
-
-      sc_id = cloud.create_stemcell("/tmp/foo", {
-        "container_format" => "ami",
-        "disk_format" => "ami",
-        "kernel_id" => "k-id",
-        "ramdisk_id" => "r-id",
-        "kernel_file" => "kernel.img",
-        "ramdisk_file" => "initrd.img"
-      })
-
-      sc_id.should == "i-bar"
-    end
-
-    it "creates stemcell using an image with kernel and ramdisk files" do
-      image = double("image", :id => "i-bar", :name => "i-bar")
-      kernel = double("image", :id => "k-img-id", :name => "k-img-id")
-      ramdisk = double("image", :id => "r-img-id", :name => "r-img-id")
-      unique_name = UUIDTools::UUID.random_create.to_s
-      kernel_params = {
-        :name => "BOSH-#{unique_name}-AKI",
-        :disk_format => "aki",
-        :container_format => "aki",
-        :location => "#{@tmp_dir}/kernel.img",
-        :properties => {
-          :stemcell => "BOSH-#{unique_name}",
-        }
-      }
-      ramdisk_params = {
-        :name => "BOSH-#{unique_name}-ARI",
-        :disk_format => "ari",
-        :container_format => "ari",
-        :location => "#{@tmp_dir}/initrd.img",
-        :properties => {
-          :stemcell => "BOSH-#{unique_name}",
-        }
-      }
-      image_params = {
-        :name => "BOSH-#{unique_name}",
-        :disk_format => "ami",
-        :container_format => "ami",
-        :location => "#{@tmp_dir}/root.img",
-        :is_public => true,
-        :properties => {
-          :kernel_id => "k-img-id",
-          :ramdisk_id => "r-img-id",
-        }
-      }
-
-      cloud = mock_glance do |glance|
-        glance.images.should_receive(:create).
-          with(kernel_params).and_return(kernel)
-        glance.images.should_receive(:create).
-          with(ramdisk_params).and_return(ramdisk)
-        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")
-      File.stub(:exists?).and_return(true)
-      cloud.should_receive(:generate_unique_name).and_return(unique_name)
-
-      sc_id = cloud.create_stemcell("/tmp/foo", {
-        "container_format" => "ami",
-        "disk_format" => "ami",
-        "kernel_file" => "kernel.img",
-        "ramdisk_file" => "initrd.img"
-      })
-
-      sc_id.should == "i-bar"
-    end
-
-    it "sets image properies from cloud_properties" do
-      image = double("image", :id => "i-bar", :name => "i-bar")
-      kernel = double("image", :id => "k-img-id", :name => "k-img-id")
-      ramdisk = double("image", :id => "r-img-id", :name => "r-img-id")
-      unique_name = UUIDTools::UUID.random_create.to_s
-      kernel_params = {
-        :name => "BOSH-#{unique_name}-AKI",
-        :disk_format => "aki",
-        :container_format => "aki",
-        :location => "#{@tmp_dir}/kernel.img",
-        :properties => {
-          :stemcell => "BOSH-#{unique_name}",
-        }
-      }
-      ramdisk_params = {
-        :name => "BOSH-#{unique_name}-ARI",
-        :disk_format => "ari",
-        :container_format => "ari",
-        :location => "#{@tmp_dir}/initrd.img",
-        :properties => {
-          :stemcell => "BOSH-#{unique_name}",
-        }
-      }
-      image_params = {
-        :name => "BOSH-#{unique_name}",
-        :disk_format => "ami",
-        :container_format => "ami",
-        :location => "#{@tmp_dir}/root.img",
-        :is_public => true,
-        :properties => {
-          :kernel_id => "k-img-id",
-          :ramdisk_id => "r-img-id",
-          :stemcell_name => "bosh-stemcell",
-          :stemcell_version => "x.y.z"
-        }
-      }
-
-      cloud = mock_glance do |glance|
-        glance.images.should_receive(:create).
-          with(kernel_params).and_return(kernel)
-        glance.images.should_receive(:create).
-          with(ramdisk_params).and_return(ramdisk)
-        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")
-      File.stub(:exists?).and_return(true)
-      cloud.should_receive(:generate_unique_name).and_return(unique_name)
-
-      sc_id = cloud.create_stemcell("/tmp/foo", {
-        "name" => "bosh-stemcell",
-        "version" => "x.y.z",
-        "container_format" => "ami",
-        "disk_format" => "ami",
-        "kernel_file" => "kernel.img",
-        "ramdisk_file" => "initrd.img"
-      })
-
-      sc_id.should == "i-bar"
-    end
-
-    it "should throw an error for non existent root image in stemcell archive" do
-      begin 
-        dir = Dir.mkdir("tmp")
-        Dir.chdir 'tmp'    
-   
-        kernel_img = File.new('kernel.img', 'w')
-        ramdisk_img = File.new('initrd.img', 'w')
-
-        tgz = Zlib::GzipWriter.new(File.open('stemcell.tgz', 'wb'))
-        array = ['kernel.img']
-    
-        Minitar.pack(array, tgz)
-      
-        cloud = mock_glance
-        error_expected = "Root image is missing from stemcell archive"
-        error_actual = ""
-        begin
-          cloud.create_stemcell("./stemcell.tgz", {
-            "name" => "bosh-stemcell",
-            "version" => "x.y.z",
-            "container_format" => "ami",
-            "disk_format" => "ami",
-            "kernel_file" => "kernel.img",
-            "ramdisk_file" => "initrd.img"
-          })
-        rescue Bosh::Clouds::CloudError => e
-          error_actual  = e.to_s
-        end
-        error_actual.should eq(error_expected)
-      ensure
-        File.delete('kernel.img')
-        File.delete('initrd.img')
-        File.delete('stemcell.tgz')
-        Dir.chdir '..'
-        Dir.delete('tmp')
-      end
-    end
-
-    it "should throw an error for non existent kernel image in stemcell archive" do
-      begin 
-        dir = Dir.mkdir("tmp")
-        Dir.chdir 'tmp'    
-        root_img = File.new('root.img','w') 
-        if root_img
-          root_img.syswrite("ABCDEF")
-        end
-        ramdisk_img = File.new('initrd.img', 'w')
-
-        tgz = Zlib::GzipWriter.new(File.open('stemcell.tgz', 'wb'))
-        array = ['root.img']
-    
-        Minitar.pack(array, tgz)
-      
-        cloud = mock_glance
-        error_expected = "Kernel image kernel.img is missing from stemcell archive"
-        error_actual = ""
-        begin
-          cloud.create_stemcell("./stemcell.tgz", {
-            "name" => "bosh-stemcell",
-            "version" => "x.y.z",
-            "container_format" => "ami",
-            "disk_format" => "ami",
-            "kernel_file" => "kernel.img",
-            "ramdisk_file" => "initrd.img"
-          })
-        rescue Bosh::Clouds::CloudError => e
-          error_actual  = e.to_s
-        end
-        error_actual.should eq(error_expected)
-      ensure
-        File.delete('root.img')
-        File.delete('initrd.img')
-        File.delete('stemcell.tgz')
-        Dir.chdir '..'
-        Dir.delete('tmp')
-      end
-    end
-
-    it "should throw an error for non existent ramdisk image in stemcell archive" do
-      begin 
-        dir = Dir.mkdir("tmp")
-        Dir.chdir 'tmp'    
-        root_img = File.new('root.img','w') 
-        if root_img
-          root_img.syswrite("ABCDEF")
-        end
-
-        tgz = Zlib::GzipWriter.new(File.open('stemcell.tgz', 'wb'))
-        array = ['root.img']
-    
-        Minitar.pack(array, tgz)
-      
-        cloud = mock_glance
-        error_expected = "Ramdisk image initrd.img is missing from stemcell archive"
-        error_actual = ""
-        begin
-          cloud.create_stemcell("./stemcell.tgz", {
-            "name" => "bosh-stemcell",
-            "version" => "x.y.z",
-            "container_format" => "ami",
-            "disk_format" => "ami",
-            #"kernel_file" => "kernel.img",
-            "ramdisk_file" => "initrd.img"
-          })
-        rescue Bosh::Clouds::CloudError => e
-          error_actual  = e.to_s
-        end
-        error_actual.should eq(error_expected)
-      ensure
-        File.delete('root.img')
-        File.delete('stemcell.tgz')
-        Dir.chdir '..'
-        Dir.delete('tmp')
-      end
-    end
-  end
-end

data/spec/unit/create_vm_spec.rb

@@ -1,252 +0,0 @@
-# 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,
-      :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, %w[default])).
-          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)
-    cloud.should_receive(:wait_resource).with(server, :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 "passes dns servers in server user data when present" do
-    unique_name = UUIDTools::UUID.random_create.to_s
-
-    user_data = {
-        "registry" => {
-          "endpoint" => "http://registry:3333"
-        },
-        "server" => {
-          "name" => "vm-#{unique_name}"
-        },
-        "dns" => {
-          "nameserver" => ["1.2.3.4"]
-        }
-    }
-    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")
-    network_spec = dynamic_network_spec
-    network_spec["dns"] = ["1.2.3.4"]
-
-    cloud = mock_cloud do |openstack|
-      openstack.servers.should_receive(:create).
-          with(openstack_params(unique_name, user_data, %w[default])).
-          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)
-    cloud.should_receive(:wait_resource).with(server, :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 "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[bar foo]
-    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)
-    cloud.should_receive(:wait_resource).with(server, :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(:find).and_return(address)
-    end
-
-    address.should_receive(:server=).with(nil)
-    address.should_receive(:server=).with(server)
-    cloud.should_receive(:wait_resource).with(server, :active, :state)
-
-    @registry.should_receive(:update_settings)
-
-    vm_id = cloud.create_vm("agent-id", "sc-id",
-                            resource_pool_spec,
-                            combined_network_spec)
-  end
-
-  def volume(zone)
-    vol = double("volume")
-    vol.stub(:availability_zone).and_return(zone)
-    vol
-  end
-
-  describe "#select_availability_zone" do
-    it "should return nil when all values are nil" do
-      cloud = mock_cloud
-      cloud.select_availability_zone(nil, nil).should == nil
-    end
-
-    it "should select the resource pool availability_zone when disks are nil" do
-      cloud = mock_cloud
-      cloud.select_availability_zone(nil, "foobar-1a").should == "foobar-1a"
-    end
-
-    it "should select the zone from a list of disks" do
-      cloud = mock_cloud do |openstack|
-        openstack.volumes.stub(:get).and_return(volume("foo"), volume("foo"))
-      end
-      cloud.select_availability_zone(%w[cid1 cid2], nil).should == "foo"
-    end
-
-    it "should select the zone from a list of disks and a default" do
-      cloud = mock_cloud do |openstack|
-        openstack.volumes.stub(:get).and_return(volume("foo"), volume("foo"))
-      end
-      cloud.select_availability_zone(%w[cid1 cid2], "foo").should == "foo"
-    end
-  end
-
-  describe "#ensure_same_availability_zone" do
-    it "should raise an error when the zones differ" do
-      cloud = mock_cloud
-      expect {
-        cloud.ensure_same_availability_zone([volume("foo"), volume("bar")],
-                                            nil)
-      }.to raise_error Bosh::Clouds::CloudError
-    end
-
-    it "should raise an error when the zones differ" do
-      cloud = mock_cloud
-      expect {
-        cloud.ensure_same_availability_zone([volume("foo"), volume("bar")],
-                                            "foo")
-      }.to raise_error Bosh::Clouds::CloudError
-    end
-
-    it "should raise an error when the zones differ" do
-      cloud = mock_cloud
-      expect {
-        cloud.ensure_same_availability_zone([volume("foo"), volume("foo")],
-                                            "bar")
-      }.to raise_error Bosh::Clouds::CloudError
-    end
-  end
-
-end