bosh_vsphere_cpi 0.4.9 → 0.5.0

data/spec/unit/cloud/vsphere/resources/datacenter_spec.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../../../../spec_helper", __FILE__)
+
+describe VSphereCloud::Resources::Datacenter do
+  before(:each) do
+    @client = mock(:client)
+    VSphereCloud::Config.client = @client
+    VSphereCloud::Config.mem_overcommit = 1.0
+  end
+
+  describe :initialize do
+    it "should create a datacenter" do
+      dc_mob = mock(:dc_mob)
+      cluster_mob = mock(:cluster_mob)
+
+      @client.should_receive(:find_by_inventory_path).with("TEST_DC").
+          and_return(dc_mob)
+      @client.should_receive(:get_managed_objects).
+          with(VimSdk::Vim::ClusterComputeResource,
+               {:root=>dc_mob, :include_name=>true}).
+          and_return({"foo" => cluster_mob})
+      @client.should_receive(:get_properties).
+          with([cluster_mob], VimSdk::Vim::ClusterComputeResource,
+               %w(name datastore resourcePool host), {:ensure_all => true}).
+          and_return({cluster_mob => {:foo => :bar}})
+
+      folder_config = VSphereCloud::Config::FolderConfig.new
+      folder_config.vm = "vms"
+      folder_config.template = "templates"
+      folder_config.shared = false
+      cluster_config = VSphereCloud::Config::ClusterConfig.new("foo")
+      datastore_config = VSphereCloud::Config::DatastoreConfig.new
+      datastore_config.disk_path = "bosh_disks"
+
+      dc_config = mock(:dc_config)
+      dc_config.stub(:name).and_return("TEST_DC")
+      dc_config.stub(:folders).and_return(folder_config)
+      dc_config.stub(:clusters).and_return({"foo" => cluster_config})
+      dc_config.stub(:datastores).and_return(datastore_config)
+
+      vm_folder = mock(:vm_folder)
+      VSphereCloud::Resources::Folder.stub!(:new).
+          with(an_instance_of(VSphereCloud::Resources::Datacenter),
+               "vms", false).
+          and_return(vm_folder)
+
+      template_folder = mock(:template_folder)
+      VSphereCloud::Resources::Folder.stub!(:new).
+          with(an_instance_of(VSphereCloud::Resources::Datacenter),
+               "templates", false).
+          and_return(template_folder)
+
+      cluster = mock(:cluster)
+      cluster.stub(:name).and_return("foo")
+      VSphereCloud::Resources::Cluster.stub!(:new).
+          with(an_instance_of(VSphereCloud::Resources::Datacenter),
+               cluster_config, {:foo => :bar}).
+          and_return(cluster)
+
+      datacenter = VSphereCloud::Resources::Datacenter.new(dc_config)
+      datacenter.mob.should == dc_mob
+      datacenter.clusters.should == {"foo" => cluster}
+      datacenter.vm_folder.should == vm_folder
+      datacenter.template_folder.should == template_folder
+      datacenter.config.should == dc_config
+      datacenter.name.should == "TEST_DC"
+      datacenter.disk_path.should == "bosh_disks"
+    end
+
+  end
+end

data/spec/unit/cloud/vsphere/resources/datastore_spec.rb

@@ -0,0 +1,43 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../../../../spec_helper", __FILE__)
+
+describe VSphereCloud::Resources::Datastore do
+  before(:each) do
+    @client = mock(:client)
+    VSphereCloud::Config.client = @client
+    VSphereCloud::Config.mem_overcommit = 1.0
+  end
+
+  describe :initialize do
+    it "should create a datastore" do
+      ds_mob = mock(:ds_mob)
+      datastore = VSphereCloud::Resources::Datastore.new({
+          :obj => ds_mob,
+          "name" => "foo_lun",
+          "summary.capacity" => 16 * 1024 * 1024 * 1024,
+          "summary.freeSpace" => 8 * 1024 * 1024 * 1024
+      })
+
+      datastore.mob.should == ds_mob
+      datastore.total_space.should == 16384
+      datastore.free_space.should == 8192
+      datastore.synced_free_space.should == 8192
+      datastore.allocated_after_sync.should == 0
+    end
+  end
+
+  describe :allocate do
+    it "should allocate space" do
+      ds_mob = mock(:ds_mob)
+      datastore = VSphereCloud::Resources::Datastore.new({
+         :obj => ds_mob,
+         "name" => "foo_lun",
+         "summary.capacity" => 16 * 1024 * 1024 * 1024,
+         "summary.freeSpace" => 8 * 1024 * 1024 * 1024
+      })
+      datastore.allocate(1024)
+      datastore.free_space.should == 7168
+    end
+  end
+end

data/spec/unit/cloud/vsphere/resources/folder_spec.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../../../../spec_helper", __FILE__)
+
+describe VSphereCloud::Resources::Folder do
+  before(:each) do
+    @client = mock(:client)
+    VSphereCloud::Config.client = @client
+    VSphereCloud::Config.mem_overcommit = 1.0
+  end
+
+  describe :initialize do
+    it "should create a folder" do
+      datacenter = mock(:datacenter)
+      datacenter.stub(:name).and_return("TEST_DC")
+
+      folder_mob = mock(:folder_mob)
+
+      @client.should_receive(:find_by_inventory_path).with(%w(TEST_DC vm foo)).
+          and_return(folder_mob)
+
+      folder = VSphereCloud::Resources::Folder.new(datacenter, "foo", false)
+      folder.mob.should == folder_mob
+      folder.name.should == "foo"
+    end
+
+    it "should create a namespaced folder" do
+      datacenter = mock(:datacenter)
+      datacenter.stub(:name).and_return("TEST_DC")
+
+      folder_mob = mock(:folder_mob)
+      @client.should_receive(:find_by_inventory_path).with(%w(TEST_DC vm foo)).
+          and_return(folder_mob)
+
+      ns_folder_mob = mock(:ns_folder_mob)
+      @client.should_receive(:find_by_inventory_path).
+          with(["TEST_DC", "vm", %w(foo 123)]).and_return(ns_folder_mob)
+
+      folder = VSphereCloud::Resources::Folder.new(datacenter, "foo", true)
+      folder.mob.should == ns_folder_mob
+      folder.name.should == %w(foo 123)
+    end
+
+    it "should create a namespaced folder and create it in vSphere" do
+      datacenter = mock(:datacenter)
+      datacenter.stub(:name).and_return("TEST_DC")
+
+      folder_mob = mock(:folder_mob)
+      @client.should_receive(:find_by_inventory_path).with(%w(TEST_DC vm foo)).
+          and_return(folder_mob)
+      @client.should_receive(:find_by_inventory_path).
+          with(["TEST_DC", "vm", %w(foo 123)]).and_return(nil)
+
+      ns_folder_mob = mock(:ns_folder_mob)
+      folder_mob.should_receive(:create_folder).with("123").
+          and_return(ns_folder_mob)
+
+      folder = VSphereCloud::Resources::Folder.new(datacenter, "foo", true)
+      folder.mob.should == ns_folder_mob
+      folder.name.should == %w(foo 123)
+    end
+  end
+end

data/spec/unit/cloud/vsphere/resources/resource_pool_spec.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../../../../spec_helper", __FILE__)
+
+describe VSphereCloud::Resources::ResourcePool do
+  before(:each) do
+    @client = mock(:client)
+    VSphereCloud::Config.client = @client
+    VSphereCloud::Config.mem_overcommit = 1.0
+  end
+
+  describe :initialize do
+    it "should create a resource pool" do
+      cluster = mock(:cluster)
+      cluster_config = VSphereCloud::Config::ClusterConfig.new("foo")
+      cluster.stub(:config).and_return(cluster_config)
+      root_resource_pool_mob = mock(:root_resource_pool)
+
+      resource_pool = VSphereCloud::Resources::ResourcePool.new(
+          cluster, root_resource_pool_mob)
+      resource_pool.mob.should == root_resource_pool_mob
+    end
+
+    it "should create a resource pool with the specified name" do
+      cluster = mock(:cluster)
+      cluster_config = VSphereCloud::Config::ClusterConfig.new(
+          {"foo" => {"resource_pool" => "bar"}})
+      cluster.stub(:config).and_return(cluster_config)
+      root_resource_pool_mob = mock(:root_resource_pool)
+
+      child_resource_pool_mob = mock(:child_resource_pool_mob)
+      @client.should_receive(:get_managed_object).
+          with(VimSdk::Vim::ResourcePool,
+               {:root=> root_resource_pool_mob, :name=>"bar"}).
+          and_return(child_resource_pool_mob)
+
+      resource_pool = VSphereCloud::Resources::ResourcePool.new(
+          cluster, root_resource_pool_mob)
+      resource_pool.mob.should == child_resource_pool_mob
+    end
+  end
+end

data/spec/unit/cloud/vsphere/resources/scorer_spec.rb

@@ -0,0 +1,73 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../../../../spec_helper", __FILE__)
+
+describe VSphereCloud::Resources::Scorer do
+
+  def create_datastores(sizes)
+    datastores = {}
+    sizes.each_with_index do |size, i|
+      datastore = mock(:datastore)
+      datastore.stub(:free_space).and_return(size)
+      datastores["ds_#{i}"] = datastore
+    end
+    datastores
+  end
+
+  def create_cluster(memory, ephemeral, persistent, shared)
+    cluster = mock(:cluster)
+    cluster.stub(:name).and_return("foo")
+    cluster.stub(:free_memory).and_return(memory)
+    cluster.stub(:ephemeral_datastores).
+        and_return(create_datastores(ephemeral))
+    cluster.stub(:persistent_datastores).
+        and_return(create_datastores(persistent))
+    cluster.stub(:shared_datastores).
+        and_return(create_datastores(shared))
+    cluster
+  end
+
+  describe :score do
+    it "should return 0 when memory is not available" do
+      cluster = create_cluster(500, [32 * 1024], [32 * 1024], [])
+      scorer = VSphereCloud::Resources::Scorer.new(cluster, 512, 1, [])
+      scorer.score.should == 0
+    end
+
+    it "should return 0 when ephemeral space is not available" do
+      cluster = create_cluster(16 * 1024, [512], [32 * 1024], [])
+      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 1024, [])
+      scorer.score.should == 0
+    end
+
+    it "should return 0 when persistent space is not available" do
+      cluster = create_cluster(16 * 1024, [32 * 1024], [512], [])
+      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 1, [1024])
+      scorer.score.should == 0
+    end
+
+    it "should calculate memory bound score" do
+      cluster = create_cluster(16 * 1024, [32 * 1024], [32 * 1024], [])
+      scorer = VSphereCloud::Resources::Scorer.new(cluster, 512, 1, [])
+      scorer.score.should == 31
+    end
+
+    it "should calculate ephemeral bound score" do
+      cluster = create_cluster(16 * 1024, [32 * 1024], [32 * 1024], [])
+      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 512, [])
+      scorer.score.should == 62
+    end
+
+    it "should calculate persistent bound score" do
+      cluster = create_cluster(16 * 1024, [32 * 1024], [32 * 1024], [])
+      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 1, [512])
+      scorer.score.should == 62
+    end
+
+    it "should calculate shared bound score" do
+      cluster = create_cluster(16 * 1024, [], [], [32 * 1024])
+      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 1024, [512])
+      scorer.score.should == 20
+    end
+  end
+end

data/spec/unit/cloud/vsphere/resources/util_spec.rb

@@ -0,0 +1,35 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../../../../spec_helper", __FILE__)
+
+describe VSphereCloud::Resources::Util do
+  describe :average_csv do
+    it "should compute the average integer value" do
+      VSphereCloud::Resources::Util.average_csv("1,2,3").should == 2
+    end
+
+    it "should compute the average float value" do
+      VSphereCloud::Resources::Util.average_csv("1.5,2.5,3.5").should == 2.5
+    end
+
+    it "should return 0 when there is no data" do
+      VSphereCloud::Resources::Util.average_csv("").should == 0
+    end
+  end
+
+  describe :weighted_random do
+    it "should calculate the weighted random" do
+      util = VSphereCloud::Resources::Util
+      util.should_receive(:rand).with(3).and_return(0)
+      util.should_receive(:rand).with(3).and_return(1)
+      util.should_receive(:rand).with(3).and_return(2)
+      util.weighted_random([[:a, 1], [:b, 2]]).should == :a
+      util.weighted_random([[:a, 1], [:b, 2]]).should == :b
+      util.weighted_random([[:a, 1], [:b, 2]]).should == :b
+    end
+
+    it "should return nil when there are no elements" do
+      VSphereCloud::Resources::Util.weighted_random([]).should be_nil
+    end
+  end
+end

data/spec/unit/cloud/vsphere/resources_spec.rb

@@ -0,0 +1,216 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require File.expand_path("../../../../spec_helper", __FILE__)
+
+describe VSphereCloud::Resources do
+
+  describe :datacenters do
+    it "should fetch the datacenters the first time" do
+      vcenter_config = mock(:vcenter_config)
+      VSphereCloud::Config.vcenter = vcenter_config
+      dc_config = mock(:dc_config)
+      dc_config.stub(:name).and_return("foo")
+      vcenter_config.stub(:datacenters).and_return({"foo" => dc_config})
+      dc = mock(:dc)
+      VSphereCloud::Resources::Datacenter.should_receive(:new).with(dc_config).
+          once.and_return(dc)
+
+      resources = VSphereCloud::Resources.new
+      resources.datacenters.should == {"foo" => dc}
+    end
+
+    it "should use cached datacenters" do
+      vcenter_config = mock(:vcenter_config)
+      VSphereCloud::Config.vcenter = vcenter_config
+      dc_config = mock(:dc_config)
+      dc_config.stub(:name).and_return("foo")
+      vcenter_config.stub(:datacenters).and_return({"foo" => dc_config})
+      dc = mock(:dc)
+      VSphereCloud::Resources::Datacenter.should_receive(:new).with(dc_config).
+          once.and_return(dc)
+
+      resources = VSphereCloud::Resources.new
+      resources.datacenters.should == {"foo" => dc}
+      resources.datacenters.should == {"foo" => dc}
+    end
+
+    it "should flush stale cached datacenters" do
+      vcenter_config = mock(:vcenter_config)
+      VSphereCloud::Config.vcenter = vcenter_config
+      dc_config = mock(:dc_config)
+      dc_config.stub(:name).and_return("foo")
+      vcenter_config.stub(:datacenters).and_return({"foo" => dc_config})
+      dc = mock(:dc)
+      VSphereCloud::Resources::Datacenter.should_receive(:new).with(dc_config).
+          twice.and_return(dc)
+
+      now = Time.now.to_i
+      Time.should_receive(:now).and_return(now, now, now + 120, now + 120)
+
+      resources = VSphereCloud::Resources.new
+      resources.datacenters.should == {"foo" => dc}
+      resources.datacenters.should == {"foo" => dc}
+    end
+  end
+
+  describe :persistent_datastore do
+    it "should return the persistent datastore" do
+      dc = mock(:dc)
+      cluster = mock(:cluster)
+      dc.stub(:clusters).and_return({"bar" => cluster})
+      datastore = mock(:datastore)
+      cluster.stub(:persistent).with("baz").and_return(datastore)
+      resources = VSphereCloud::Resources.new
+      resources.stub(:datacenters).and_return({"foo" => dc})
+      resources.persistent_datastore("foo", "bar", "baz").should == datastore
+      resources.persistent_datastore("foo", "ba", "baz").should be_nil
+    end
+  end
+
+  describe :validate_persistent_datastore do
+    it "should return true if the provided datastore is still persistent" do
+      dc = mock(:dc)
+      cluster = mock(:cluster)
+      dc.stub(:clusters).and_return({"bar" => cluster})
+      datastore = mock(:datastore)
+      cluster.stub(:persistent).with("baz").and_return(datastore)
+      resources = VSphereCloud::Resources.new
+      resources.stub(:datacenters).and_return({"foo" => dc})
+      resources.validate_persistent_datastore("foo", "baz").should be_true
+    end
+
+    it "should return false if the provided datastore is not persistent" do
+      dc = mock(:dc)
+      cluster = mock(:cluster)
+      dc.stub(:clusters).and_return({"bar" => cluster})
+      cluster.stub(:persistent).with("baz").and_return(nil)
+      resources = VSphereCloud::Resources.new
+      resources.stub(:datacenters).and_return({"foo" => dc})
+      resources.validate_persistent_datastore("foo", "baz").should be_false
+    end
+  end
+
+  describe :place_persistent_datastore do
+    it "should return the datastore when it was placed successfully" do
+      dc = mock(:dc)
+      cluster = mock(:cluster)
+      dc.stub(:clusters).and_return({"bar" => cluster})
+      datastore = mock(:datastore)
+      datastore.should_receive(:allocate).with(1024)
+      cluster.should_receive(:pick_persistent).with(1024).and_return(datastore)
+      resources = VSphereCloud::Resources.new
+      resources.stub(:datacenters).and_return({"foo" => dc})
+      resources.place_persistent_datastore("foo", "bar", 1024).
+          should == datastore
+    end
+
+    it "should return nil when it wasn't placed successfully" do
+      dc = mock(:dc)
+      cluster = mock(:cluster)
+      dc.stub(:clusters).and_return({"bar" => cluster})
+      cluster.should_receive(:pick_persistent).with(1024).and_return(nil)
+      resources = VSphereCloud::Resources.new
+      resources.stub(:datacenters).and_return({"foo" => dc})
+      resources.place_persistent_datastore("foo", "bar", 1024).
+          should be_nil
+    end
+  end
+
+  describe :place do
+    it "should allocate memory and ephemeral disk space" do
+      dc = mock(:dc)
+      cluster = mock(:cluster)
+      dc.stub(:clusters).and_return({"bar" => cluster})
+      datastore = mock(:datastore)
+      cluster.stub(:name).and_return("bar")
+      cluster.stub(:persistent).with("baz").and_return(datastore)
+      resources = VSphereCloud::Resources.new
+      resources.stub(:datacenters).and_return({"foo" => dc})
+
+      scorer = mock(:scorer)
+      scorer.should_receive(:score).and_return(4)
+      VSphereCloud::Resources::Scorer.should_receive(:new).
+          with(cluster, 512, 1024, []).and_return(scorer)
+
+      cluster.should_receive(:allocate).with(512)
+      cluster.should_receive(:pick_ephemeral).with(1024).and_return(datastore)
+      datastore.should_receive(:allocate).with(1024)
+
+      resources.place(512, 1024, []).should == [cluster, datastore]
+    end
+
+    it "should prioritize persistent locality" do
+      dc = mock(:dc)
+      cluster_a = mock(:cluster_a)
+      cluster_b = mock(:cluster_b)
+      dc.stub(:clusters).and_return({"a" => cluster_a, "b" => cluster_b})
+
+      datastore_a = mock(:datastore_a)
+      cluster_a.stub(:name).and_return("ds_a")
+      cluster_a.stub(:persistent).with("ds_a").and_return(datastore_a)
+      cluster_a.stub(:persistent).with("ds_b").and_return(nil)
+
+      datastore_b = mock(:datastore_b)
+      cluster_b.stub(:name).and_return("ds_b")
+      cluster_b.stub(:persistent).with("ds_a").and_return(nil)
+      cluster_b.stub(:persistent).with("ds_b").and_return(datastore_b)
+
+      resources = VSphereCloud::Resources.new
+      resources.stub(:datacenters).and_return({"foo" => dc})
+
+      scorer_b = mock(:scorer_a)
+      scorer_b.should_receive(:score).and_return(4)
+      VSphereCloud::Resources::Scorer.should_receive(:new).
+          with(cluster_b, 512, 1024, [2048]).and_return(scorer_b)
+
+      cluster_b.should_receive(:allocate).with(512)
+      cluster_b.should_receive(:pick_ephemeral).with(1024).
+          and_return(datastore_b)
+      datastore_b.should_receive(:allocate).with(1024)
+
+      resources.place(512, 1024,
+                      [{:size => 2048, :dc_name => "foo", :ds_name => "ds_a"},
+                       {:size => 4096, :dc_name => "foo", :ds_name => "ds_b"}]).
+          should == [cluster_b, datastore_b]
+    end
+
+    it "should ignore locality when there is no space" do
+      dc = mock(:dc)
+      cluster_a = mock(:cluster_a)
+      cluster_b = mock(:cluster_b)
+      dc.stub(:clusters).and_return({"a" => cluster_a, "b" => cluster_b})
+
+      datastore_a = mock(:datastore_a)
+      cluster_a.stub(:name).and_return("ds_a")
+      cluster_a.stub(:persistent).with("ds_a").and_return(datastore_a)
+      cluster_a.stub(:persistent).with("ds_b").and_return(nil)
+
+      datastore_b = mock(:datastore_b)
+      cluster_b.stub(:name).and_return("ds_b")
+      cluster_b.stub(:persistent).with("ds_a").and_return(nil)
+      cluster_b.stub(:persistent).with("ds_b").and_return(datastore_b)
+
+      resources = VSphereCloud::Resources.new
+      resources.stub(:datacenters).and_return({"foo" => dc})
+
+      scorer_a = mock(:scorer_a)
+      scorer_a.should_receive(:score).twice.and_return(0)
+      VSphereCloud::Resources::Scorer.should_receive(:new).
+          with(cluster_a, 512, 1024, []).twice.and_return(scorer_a)
+
+      scorer_b = mock(:scorer_b)
+      scorer_b.should_receive(:score).and_return(4)
+      VSphereCloud::Resources::Scorer.should_receive(:new).
+          with(cluster_b, 512, 1024, [2048]).and_return(scorer_b)
+
+      cluster_b.should_receive(:allocate).with(512)
+      cluster_b.should_receive(:pick_ephemeral).with(1024).
+          and_return(datastore_b)
+      datastore_b.should_receive(:allocate).with(1024)
+
+      resources.place(512, 1024,
+                      [{:size => 2048, :dc_name => "foo", :ds_name => "ds_a"}]).
+          should == [cluster_b, datastore_b]
+    end
+  end
+end