bosh_vsphere_cpi 2.2.0 → 2.2.1

data/lib/cloud/vsphere/cloud.rb

@@ -17,7 +17,7 @@ module VSphereCloud
     end
 
     attr_accessor :client
-    attr_reader :datacenter
+    attr_reader :config, :datacenter
 
     def initialize(options)
       @config = Config.build(options)
@@ -39,7 +39,6 @@ module VSphereCloud
         mem_overcommit: @config.mem_overcommit
       })
 
-      @resources = Resources.new(@datacenter, config)
       @file_provider = FileProvider.new(config.rest_client, config.vcenter_host)
       @agent_env = AgentEnv.new(client, @file_provider, @cloud_searcher)
 
@@ -67,7 +66,7 @@ module VSphereCloud
     end
 
     def has_disk?(disk_cid)
-      disk_provider.find(disk_cid)
+      @datacenter.find_disk(disk_cid)
       true
     rescue Bosh::Clouds::DiskNotFound
       false
@@ -89,8 +88,12 @@ module VSphereCloud
           @logger.info("Generated name: #{name}")
 
           stemcell_size = File.size(image) / (1024 * 1024)
-          cluster = @resources.pick_cluster_for_vm(0, stemcell_size, [])
-          datastore = @resources.pick_ephemeral_datastore(cluster, stemcell_size)
+
+          cluster = @datacenter.pick_cluster_for_vm(0, stemcell_size, [])
+          if cluster.ephemeral_datastores.empty?
+            raise "Cluster '#{cluster.name}' has no ephemeral datastores"
+          end
+          datastore = @datacenter.pick_ephemeral_datastore(stemcell_size, cluster.ephemeral_datastores.keys)
           @logger.info("Deploying to: #{cluster.mob} / #{datastore.mob}")
 
           import_spec_result = import_ovf(name, ovf_file, cluster.resource_pool.mob, datastore.mob)
@@ -113,7 +116,7 @@ module VSphereCloud
 
           nics = devices.select { |device| device.kind_of?(Vim::Vm::Device::VirtualEthernetCard) }
           nics.each do |nic|
-            nic_config = create_delete_device_spec(nic)
+            nic_config = Resources::VM.create_delete_device_spec(nic)
             config.device_change << nic_config
           end
           client.reconfig_vm(vm, config)
@@ -155,8 +158,20 @@ module VSphereCloud
 
     def create_vm(agent_id, stemcell, cloud_properties, networks, disk_locality = nil, environment = nil)
       with_thread_name("create_vm(#{agent_id}, ...)") do
+        datacenter_spec = cloud_properties.fetch('datacenters', []).first
+        cluster_spec = datacenter_spec.fetch('clusters', []).first if datacenter_spec
+
+        drs_rules = []
+        cluster = nil
+        unless cluster_spec.nil?
+          cluster_name = cluster_spec.keys.first
+          spec = cluster_spec.values.first
+          cluster_config = ClusterConfig.new(cluster_name, spec)
+          cluster = Resources::ClusterProvider.new(@datacenter, @client, @logger).find(cluster_name, cluster_config)
+          drs_rules = spec.fetch('drs_rules', [])
+        end
+
         VmCreatorBuilder.new.build(
-          choose_placer(cloud_properties),
           cloud_properties,
           @client,
           @cloud_searcher,
@@ -164,7 +179,9 @@ module VSphereCloud
           self,
           @agent_env,
           @file_provider,
-          disk_provider
+          @datacenter,
+          cluster,
+          drs_rules
         ).create(agent_id, stemcell, networks, disk_locality, environment)
       end
     end
@@ -178,15 +195,7 @@ module VSphereCloud
 
         persistent_disks = vm.persistent_disks
         unless persistent_disks.empty?
-          @logger.info("Found #{persistent_disks.size} persistent disk(s)")
-          config = Vim::Vm::ConfigSpec.new
-          config.device_change = []
-          persistent_disks.each do |virtual_disk|
-            @logger.info("Detaching: #{virtual_disk.backing.file_name}")
-            config.device_change << create_delete_device_spec(virtual_disk)
-          end
-          retry_block { client.reconfig_vm(vm.mob, config) }
-          @logger.info("Detached #{persistent_disks.size} persistent disk(s)")
+          vm.detach_disks(persistent_disks)
         end
 
         # Delete env.iso and VM specific files managed by the director
@@ -247,6 +256,8 @@ module VSphereCloud
           if e.fault.kind_of?(Vim::Fault::NoPermission)
             @logger.warn("Can't set custom fields due to lack of " +
                            "permission: #{e.message}")
+          elsif e.fault.kind_of?(Vim::Fault::DuplicateName)
+            @logger.warn("Can't add custom field definition that already exists: #{e.message}")
           else
             raise e
           end
@@ -263,7 +274,7 @@ module VSphereCloud
         config = Vim::Vm::ConfigSpec.new
         config.device_change = []
         vm.nics.each do |nic|
-          nic_config = create_delete_device_spec(nic)
+          nic_config = Resources::VM.create_delete_device_spec(nic)
           config.device_change << nic_config
         end
 
@@ -271,7 +282,9 @@ module VSphereCloud
         networks.each_value do |network|
           v_network_name = network['cloud_properties']['name']
           network_mob = client.find_by_inventory_path([@datacenter.name, 'network', v_network_name])
-          nic_config = create_nic_config_spec(v_network_name, network_mob, vm.pci_controller.key, dvs_index)
+
+          virtual_nic = Resources::Nic.create_virtual_nic(@cloud_searcher, v_network_name, network_mob, vm.pci_controller.key, dvs_index)
+          nic_config = Resources::VM.create_add_device_spec(virtual_nic)
           config.device_change << nic_config
         end
 
@@ -301,72 +314,24 @@ module VSphereCloud
     def attach_disk(vm_cid, disk_cid)
       with_thread_name("attach_disk(#{vm_cid}, #{disk_cid})") do
         @logger.info("Attaching disk: #{disk_cid} on vm: #{vm_cid}")
-
         vm = vm_provider.find(vm_cid)
-        cluster = @datacenter.clusters[vm.cluster]
-
-        disk = disk_provider.find_and_move(disk_cid, cluster, @datacenter, vm.accessible_datastores)
-        disk_config_spec = disk.attach_spec(vm.system_disk.controller_key)
-
-        vm_config = Vim::Vm::ConfigSpec.new
-        vm_config.device_change = []
-        vm_config.device_change << disk_config_spec
-        vm.fix_device_unit_numbers(vm_config.device_change)
-
-        env = @agent_env.get_current_env(vm.mob, @datacenter.name)
-        @logger.info("Reading current agent env: #{env.pretty_inspect}")
-        env['disks']['persistent'][disk_cid] = disk_config_spec.device.unit_number.to_s
-        @logger.info("Updating agent env to: #{env.pretty_inspect}")
-
-        location = get_vm_location(vm.mob, datacenter: @datacenter.name)
-        @agent_env.set_env(vm.mob, location, env)
-        @logger.info('Attaching disk')
-        client.reconfig_vm(vm.mob, vm_config)
-        @logger.info('Finished attaching disk')
+        disk = @datacenter.find_disk(disk_cid)
+        disk = @datacenter.ensure_disk_is_accessible_to_vm(disk, vm)
+        disk_config_spec = vm.attach_disk(disk)
+        add_disk_to_agent_env(vm, disk, disk_config_spec.device.unit_number)
       end
     end
 
     def detach_disk(vm_cid, disk_cid)
       with_thread_name("detach_disk(#{vm_cid}, #{disk_cid})") do
         @logger.info("Detaching disk: #{disk_cid} from vm: #{vm_cid}")
-        disk = disk_provider.find(disk_cid)
-        vm = vm_provider.find(vm_cid)
-        vm_mob = vm.mob
-
-        location = get_vm_location(vm_mob)
-        env = @agent_env.get_current_env(vm_mob, location[:datacenter])
-        @logger.info("Reading current agent env: #{env.pretty_inspect}")
-        if env['disks']['persistent'][disk.cid]
-          env['disks']['persistent'].delete(disk.cid)
-          @logger.info("Updating agent env to: #{env.pretty_inspect}")
-
-          @agent_env.set_env(vm_mob, location, env)
-        end
-
-        vm.reload
-        virtual_disk = vm.disk_by_cid(disk.cid)
-        raise Bosh::Clouds::DiskNotAttached.new(true), "Disk '#{disk.cid}' is not attached to VM '#{vm.cid}'" if virtual_disk.nil?
 
-        config = Vim::Vm::ConfigSpec.new
-        config.device_change = []
-        config.device_change << create_delete_device_spec(virtual_disk)
-
-        @logger.info('Detaching disk')
-        client.reconfig_vm(vm_mob, config)
-
-        # detach-disk is async and task completion does not necessarily mean
-        # that changes have been applied to VC side. Query VC until we confirm
-        # that the change has been applied. This is a known issue for vsphere 4.
-        # Fixed in vsphere 5.
-        5.times do
-          vm.reload
-          virtual_disk = vm.disk_by_cid(disk.cid)
-          break if virtual_disk.nil?
-          sleep(1.0)
-        end
-        raise "Failed to detach disk '#{disk.cid}' from vm '#{vm.cid}'" unless virtual_disk.nil?
+        vm = vm_provider.find(vm_cid)
+        disk = vm.disk_by_original_cid(disk_cid)
+        raise Bosh::Clouds::DiskNotAttached.new(true), "Disk '#{disk_cid}' is not attached to VM '#{vm_cid}'" if disk.nil?
 
-        @logger.info('Finished detaching disk')
+        delete_disk_from_agent_env(vm, disk_cid)
+        vm.detach_disks([disk])
       end
     end
 
@@ -374,15 +339,17 @@ module VSphereCloud
       with_thread_name("create_disk(#{size_in_mb}, _)") do
         @logger.info("Creating disk with size: #{size_in_mb}")
 
-        cluster = nil
+        filtered_datastores = []
         if vm_cid
           vm = vm_provider.find(vm_cid)
-          cluster = @datacenter.clusters[vm.cluster]
+          filtered_datastores = vm.accessible_datastores
         end
 
-        disk_type = cloud_properties['type']
-        disk = disk_provider.create(size_in_mb, disk_type, cluster)
+        datastore = @datacenter.pick_persistent_datastore(size_in_mb, filtered_datastores)
+        disk_type = cloud_properties.fetch('type', Resources::PersistentDisk::DEFAULT_DISK_TYPE)
+        disk = @datacenter.create_disk(datastore, size_in_mb, disk_type)
         @logger.info("Created disk: #{disk.inspect}")
+
         disk.cid
       end
     end
@@ -390,39 +357,82 @@ module VSphereCloud
     def delete_disk(disk_cid)
       with_thread_name("delete_disk(#{disk_cid})") do
         @logger.info("Deleting disk: #{disk_cid}")
-        disk = disk_provider.find(disk_cid)
+        disk = @datacenter.find_disk(disk_cid)
         client.delete_disk(@datacenter.mob, disk.path)
 
         @logger.info('Finished deleting disk')
       end
     end
 
-    def replicate_stemcell(cluster, datastore, stemcell)
-      stemcell_vm = client.find_vm_by_name(@datacenter, stemcell)
-      raise "Could not find VM for stemcell '#{stemcell}'" if stemcell_vm.nil?
-      stemcell_datastore = @cloud_searcher.get_property(stemcell_vm, Vim::VirtualMachine, 'datastore', ensure_all: true)
+    def replicate_stemcell(cluster, to_datastore, stemcell_id)
+      original_stemcell_vm = self.client.find_vm_by_name(@datacenter, stemcell_id)
+      raise "Could not find VM for stemcell '#{stemcell_id}'" if original_stemcell_vm.nil?
+
+      return original_stemcell_vm if vm_datastore_name(original_stemcell_vm) == to_datastore.name
+
+      @logger.info("Stemcell lives on a different datastore, looking for a local copy of: #{stemcell_id}.")
+
+      name_of_replicated_stemcell = "#{stemcell_id} %2f #{to_datastore.mob.__mo_id__}"
+
+      replicated_stemcell_vm = client.find_vm_by_name(@datacenter, name_of_replicated_stemcell)
+      return replicated_stemcell_vm if replicated_stemcell_vm
+
+      @logger.info("Cluster doesn't have stemcell #{stemcell_id}, replicating")
+      @logger.info("Replicating #{stemcell_id} (#{original_stemcell_vm}) to #{name_of_replicated_stemcell}")
+      begin
+        replicated_stemcell_vm = client.wait_for_task(clone_vm(
+          original_stemcell_vm,
+          name_of_replicated_stemcell,
+          cluster.datacenter.template_folder.mob,
+          cluster.resource_pool.mob,
+          datastore: to_datastore.mob
+        ))
+        @logger.info("Replicated #{stemcell_id} (#{original_stemcell_vm}) to #{name_of_replicated_stemcell} (#{replicated_stemcell_vm})")
+
+        @logger.info("Creating initial snapshot for linked clones on #{replicated_stemcell_vm}")
+        client.wait_for_task(replicated_stemcell_vm.create_snapshot('initial', nil, false, false))
+        @logger.info("Created initial snapshot for linked clones on #{replicated_stemcell_vm}")
+      rescue VSphereCloud::Client::DuplicateName
+        @logger.info("Stemcell is being replicated by another thread, waiting for #{name_of_replicated_stemcell} to be ready")
+        replicated_stemcell_vm = client.find_by_inventory_path([
+          cluster.datacenter.name,
+          'vm',
+          cluster.datacenter.template_folder.path_components,
+          name_of_replicated_stemcell
+        ])
+        # get_properties will ensure the existence of the snapshot by retrying.
+        # This forces us to wait for a valid snapshot before returning with the
+        # replicated stemcell vm, if a snapshot is not found then an exception is thrown.
+        client.cloud_searcher.get_properties(replicated_stemcell_vm,
+          VimSdk::Vim::VirtualMachine,
+          ['snapshot'], ensure_all: true)
+        @logger.info("Stemcell #{name_of_replicated_stemcell} has been replicated.")
+      end
+
+      replicated_stemcell_vm
+    end
+
 
-      if stemcell_datastore != datastore.mob
-        @logger.info("Stemcell lives on a different datastore, looking for a local copy of: #{stemcell}.")
-        local_stemcell_name = "#{stemcell} %2f #{datastore.mob.__mo_id__}"
+    def vm_datastore_name(vm)
+      vm_datacenters = @cloud_searcher.get_property(
+        vm,
+        Vim::VirtualMachine,
+        'datastore',
+        ensure_all: true
+      )
 
-        replicated_stemcell_vm = client.find_vm_by_name(@datacenter, local_stemcell_name)
-        if replicated_stemcell_vm.nil?
-          @logger.info("Cluster doesn't have stemcell #{stemcell}, replicating")
-          replicated_stemcell_vm = replicate_stemcell_helper(stemcell, stemcell_vm, local_stemcell_name, cluster, datastore, replicated_stemcell_vm)
-        else
-          @logger.info("Found local stemcell replica: #{replicated_stemcell_vm}")
-        end
-        result = replicated_stemcell_vm
-      else
-        @logger.info("Stemcell was already local: #{stemcell_vm}")
-        result = stemcell_vm
+      if vm_datacenters.size > 1
+        raise "stemcell VM #{vm.inspect} found in multiple datacenters #{datacenters.inspect}"
       end
-      @logger.info("Using stemcell VM: #{result}")
 
-      result
+      if vm_datacenters.size == 0
+        raise "no datacenter found for stemcell VM #{vm.inspect}"
+      end
+
+      vm_datacenters.first.name
     end
 
+
     def generate_network_env(devices, networks, dvs_index)
       nics = {}
 
@@ -533,52 +543,6 @@ module VSphereCloud
       vm.clone(folder, name, clone_spec)
     end
 
-    def create_nic_config_spec(v_network_name, network, controller_key, dvs_index)
-      raise "Invalid network '#{v_network_name}'" if network.nil?
-      if network.class == Vim::Dvs::DistributedVirtualPortgroup
-        portgroup_properties = @cloud_searcher.get_properties(network,
-                                                     Vim::Dvs::DistributedVirtualPortgroup,
-                                                     ['config.key', 'config.distributedVirtualSwitch'],
-                                                     ensure_all: true)
-
-        switch = portgroup_properties['config.distributedVirtualSwitch']
-        switch_uuid = @cloud_searcher.get_property(switch, Vim::DistributedVirtualSwitch, 'uuid', ensure_all: true)
-
-        port = Vim::Dvs::PortConnection.new
-        port.switch_uuid = switch_uuid
-        port.portgroup_key = portgroup_properties['config.key']
-
-        backing_info = Vim::Vm::Device::VirtualEthernetCard::DistributedVirtualPortBackingInfo.new
-        backing_info.port = port
-
-        dvs_index[port.portgroup_key] = v_network_name
-      else
-        backing_info = Vim::Vm::Device::VirtualEthernetCard::NetworkBackingInfo.new
-        backing_info.device_name = network.name
-        backing_info.network = network
-      end
-
-      nic = Vim::Vm::Device::VirtualVmxnet3.new
-      nic.key = -1
-      nic.controller_key = controller_key
-      nic.backing = backing_info
-
-      device_config_spec = Vim::Vm::Device::VirtualDeviceSpec.new
-      device_config_spec.device = nic
-      device_config_spec.operation = Vim::Vm::Device::VirtualDeviceSpec::Operation::ADD
-      device_config_spec
-    end
-
-    def create_delete_device_spec(device, options = {})
-      device_config_spec = Vim::Vm::Device::VirtualDeviceSpec.new
-      device_config_spec.device = device
-      device_config_spec.operation = Vim::Vm::Device::VirtualDeviceSpec::Operation::REMOVE
-      if options[:destroy]
-        device_config_spec.file_operation = Vim::Vm::Device::VirtualDeviceSpec::FileOperation::DESTROY
-      end
-      device_config_spec
-    end
-
     def import_ovf(name, ovf, resource_pool, datastore)
       import_spec_params = Vim::OvfManager::CreateImportSpecParams.new
       import_spec_params.entity_name = name
@@ -672,71 +636,28 @@ module VSphereCloud
       )
     end
 
-    def disk_provider
-      DiskProvider.new(
-        @client.service_content.virtual_disk_manager,
-        @datacenter,
-        @resources,
-        @config.datacenter_disk_path,
-        @client,
-        @logger
-      )
-    end
-
     private
 
-    def choose_placer(cloud_properties)
-      datacenter_spec = cloud_properties.fetch('datacenters', []).first
-      cluster_spec = datacenter_spec.fetch('clusters', []).first if datacenter_spec
-
-      unless cluster_spec.nil?
-        cluster_name = cluster_spec.keys.first
-        spec = cluster_spec.values.first
-        cluster_config = ClusterConfig.new(cluster_name, spec)
-        cluster = Resources::ClusterProvider.new(@datacenter, @client, @logger).find(cluster_name, cluster_config)
-        drs_rules = spec.fetch('drs_rules', [])
-        placer = FixedClusterPlacer.new(cluster, drs_rules)
-      end
-
-      placer.nil? ? @resources : placer
-    end
-
-  def replicate_stemcell_helper(stemcell, stemcell_vm, local_stemcell_name, cluster, datastore, replicated_stemcell_vm)
-    @logger.info("Replicating #{stemcell} (#{stemcell_vm}) to #{local_stemcell_name}")
-    task = clone_vm(stemcell_vm,
-                    local_stemcell_name,
-                    cluster.datacenter.template_folder.mob,
-                    cluster.resource_pool.mob,
-                    datastore: datastore.mob)
-    begin
-      replicated_stemcell_vm = client.wait_for_task(task)
-      @logger.info("Replicated #{stemcell} (#{stemcell_vm}) to #{local_stemcell_name} (#{replicated_stemcell_vm})")
-    rescue VSphereCloud::Client::DuplicateName => ex
-      @logger.info("Stemcell is being replicated by another thread, waiting for #{local_stemcell_name} to be ready")
-      local_stemcell_path =
-        [cluster.datacenter.name, 'vm', cluster.datacenter.template_folder.path_components, local_stemcell_name]
-      replicated_stemcell_vm = client.find_by_inventory_path(local_stemcell_path)
-      # get_properties will ensure the existence of the snapshot by retrying.
-      # This forces us to wait for a valid snapshot before returning with the
-      # replicated stemcell vm, if a snapshot is not found then an exception is thrown.
-      client.cloud_searcher.get_properties(replicated_stemcell_vm,
-                                           VimSdk::Vim::VirtualMachine,
-                                           ['snapshot'], ensure_all: true)
-      @logger.info("Stemcell #{local_stemcell_name} has been replicated.")
-
-      return replicated_stemcell_vm
-    end
-    # Despite the naming, this has nothing to do with the Cloud notion of a disk snapshot
-    # (which comes from AWS). This is a vm snapshot.
-    @logger.info("Creating initial snapshot for linked clones on #{replicated_stemcell_vm}")
-    task = replicated_stemcell_vm.create_snapshot('initial', nil, false, false)
-    client.wait_for_task(task)
-    @logger.info("Created initial snapshot for linked clones on #{replicated_stemcell_vm}")
-
-    replicated_stemcell_vm
-  end
-
-  attr_reader :config
+    def add_disk_to_agent_env(vm, disk, device_unit_number)
+      env = @agent_env.get_current_env(vm.mob, @datacenter.name)
+      @logger.info("Reading current agent env: #{env.pretty_inspect}")
+      env['disks']['persistent'][disk.cid] = device_unit_number.to_s
+      location = get_vm_location(vm.mob, datacenter: @datacenter.name)
+      @agent_env.set_env(vm.mob, location, env)
+      @logger.info("Updated agent env to: #{env.pretty_inspect}")
+    end
+
+    def delete_disk_from_agent_env(vm, disk_cid)
+      vm_mob = vm.mob
+      location = get_vm_location(vm_mob)
+      env = @agent_env.get_current_env(vm_mob, location[:datacenter])
+      @logger.info("Reading current agent env: #{env.pretty_inspect}")
+      if env['disks']['persistent'][disk_cid]
+        env['disks']['persistent'].delete(disk_cid)
+        @logger.info("Updating agent env to: #{env.pretty_inspect}")
 
+        @agent_env.set_env(vm_mob, location, env)
+      end
+    end
   end
 end

data/lib/cloud/vsphere/config.rb

@@ -157,10 +157,7 @@ module VSphereCloud
               'datastore_pattern' => String,
               'persistent_datastore_pattern' => String,
               optional('allow_mixed_datastores') => bool,
-              'clusters' => [enum(String,
-                dict(String, {
-                  'resource_pool' => String
-                })
+              'clusters' => [enum(String, dict(String, {optional('resource_pool') => String})
               )]
             }]
           }]

data/lib/cloud/vsphere/resources/cluster.rb

@@ -1,7 +1,7 @@
 require 'cloud/vsphere/resources/resource_pool'
 
 module VSphereCloud
-  class Resources
+  module Resources
     class Cluster
       include VimSdk
       include ObjectStringifier
@@ -11,6 +11,8 @@ module VSphereCloud
       HOST_PROPERTIES = %w(hardware.memorySize runtime.inMaintenanceMode)
       HOST_COUNTERS = %w(mem.usage.average)
 
+      MEMORY_HEADROOM = 128
+
       # @!attribute mob
       #   @return [Vim::ClusterComputeResource] cluster vSphere MOB.
       attr_reader :mob
@@ -80,24 +82,6 @@ module VSphereCloud
         @allocated_after_sync += memory
       end
 
-      # Picks the best datastore for the specified persistent disk.
-      #
-      # @param [Integer] size persistent disk size.
-      # @return [Datastore] the best datastore for the requested size.
-      # @raise [Bosh::Clouds::NoDiskSpace] if no datastore available for the requested size
-      def pick_persistent(size)
-        pick_store(:persistent, size)
-      end
-
-      # Picks the best datastore for the specified ephemeral disk.
-      #
-      # @param [Integer] size ephemeral disk size.
-      # @return [Datastore] the best datastore for the requested size.
-      # @raise [Bosh::Clouds::NoDiskSpace] if no datastore available for the requested size
-      def pick_ephemeral(size)
-        pick_store(:ephemeral, size)
-      end
-
       # @return [String] cluster name.
       def name
         config.name
@@ -108,6 +92,13 @@ module VSphereCloud
         "<Cluster: #{mob} / #{config.name}>"
       end
 
+      # @return [String] more descriptive debug cluster information.
+      def describe
+        "#{name} has #{free_memory}mb/" +
+          "#{total_free_ephemeral_disk_in_mb / 1024}gb/" +
+          "#{total_free_persistent_disk_in_mb / 1024}gb"
+      end
+
       def ephemeral_datastores
         @ephemeral_datastores ||= select_datastores(@datacenter_datastore_pattern)
       end
@@ -134,22 +125,6 @@ module VSphereCloud
         all_datastores.select { |name, datastore| name =~ pattern }
       end
 
-      def pick_store(type, size)
-        datastores = (type == :ephemeral ? ephemeral_datastores : persistent_datastores).values
-        available_datastores = datastores.reject { |datastore| datastore.free_space - size < DISK_HEADROOM }
-
-        @logger.debug("Looking for a #{type} datastore in #{self.name} with #{size}MB free space.")
-        @logger.debug("All datastores within cluster #{self.name}: #{datastores.map(&:debug_info)}")
-        @logger.debug("Datastores with enough space: #{available_datastores.map(&:debug_info)}")
-
-        selected_datastore = Util.weighted_random(available_datastores.map { |datastore| [datastore, datastore.free_space] })
-
-        if selected_datastore.nil?
-          raise Bosh::Clouds::NoDiskSpace.new(true), "Couldn't find a #{type} datastore with #{size}MB of free space accessible from cluster '#{self.name}'. Found:\n #{datastores.map(&:debug_info).join("\n ")}\n"
-        end
-        selected_datastore
-      end
-
       def synced_free_memory
         return @synced_free_memory if @synced_free_memory
         # Have to use separate mechanisms for fetching utilization depending on

data/lib/cloud/vsphere/resources/cluster_provider.rb

@@ -1,5 +1,5 @@
 module VSphereCloud
-  class Resources
+  module Resources
     class ClusterProvider
       def initialize(datacenter, client, logger)
         @datacenter = datacenter