bosh_vsphere_cpi 1.2865.0 → 1.2881.0

data/lib/cloud/vsphere/disk_provider.rb

@@ -0,0 +1,91 @@
+require 'ostruct'
+require 'cloud/vsphere/resources/disk'
+
+module VSphereCloud
+  class DiskProvider
+    def initialize(virtual_disk_manager, datacenter, resources, disk_path, client, logger)
+      @virtual_disk_manager = virtual_disk_manager
+      @datacenter = datacenter
+      @resources = resources
+      @disk_path = disk_path
+      @client = client
+      @logger = logger
+    end
+
+    def create(disk_size_in_mb)
+      datastore = find_datastore(disk_size_in_mb)
+      disk_cid = "disk-#{SecureRandom.uuid}"
+      @logger.debug("Creating disk '#{disk_cid}' in datastore '#{datastore.name}'")
+
+      disk_spec = VimSdk::Vim::VirtualDiskManager::FileBackedVirtualDiskSpec.new
+      disk_spec.disk_type = 'preallocated'
+      disk_spec.capacity_kb = disk_size_in_mb * 1024
+      disk_spec.adapter_type = 'lsiLogic'
+
+      disk_path = path(datastore, disk_cid)
+      create_parent_folder(disk_path)
+
+      task = @virtual_disk_manager.create_virtual_disk(
+        disk_path,
+        @datacenter.mob,
+        disk_spec
+      )
+      @client.wait_for_task(task)
+
+      Resources::Disk.new(disk_cid, disk_size_in_mb, datastore, disk_path)
+    end
+
+    def find_and_move(disk_cid, cluster, datacenter_name, accessible_datastores)
+      disk = find(disk_cid)
+      return disk if accessible_datastores.include?(disk.datastore.name)
+
+      destination_datastore =  @resources.pick_persistent_datastore_in_cluster(cluster, disk.size_in_mb)
+      if destination_datastore.nil?
+        raise Bosh::Clouds::NoDiskSpace.new(true),
+          "Not enough persistent space on cluster '#{cluster.name}', requested disk size: #{disk.size_in_mb}Mb"
+      end
+
+      unless accessible_datastores.include?(destination_datastore.name)
+        raise "Datastore '#{destination_datastore.name}' is not accessible to cluster '#{cluster.name}'"
+      end
+
+      destination_path = path(destination_datastore, disk_cid)
+      @logger.info("Moving #{disk.path} to #{destination_path}")
+      create_parent_folder(destination_path)
+      @client.move_disk(datacenter_name, disk.path, datacenter_name, destination_path) #TODO: return the new disk
+      @logger.info('Moved disk successfully')
+      Resources::Disk.new(disk_cid, disk.size_in_mb, destination_datastore, destination_path)
+    end
+
+    def find(disk_cid)
+      @datacenter.persistent_datastores.each do |_, datastore|
+        disk = @client.find_disk(disk_cid, datastore, @disk_path)
+        return disk unless disk.nil?
+      end
+
+      raise Bosh::Clouds::DiskNotFound, "Could not find disk with id #{disk_cid}"
+    end
+
+    private
+
+    def path(datastore, disk_cid)
+      "[#{datastore.name}] #{@disk_path}/#{disk_cid}.vmdk"
+    end
+
+    def find_datastore(disk_size_in_mb)
+      datastore = @datacenter.pick_persistent_datastore(disk_size_in_mb)
+
+      if datastore.nil?
+        raise Bosh::Clouds::NoDiskSpace.new(true),
+          "Not enough persistent space #{disk_size_in_mb}"
+      end
+
+      datastore
+    end
+
+    def create_parent_folder(disk_path)
+      destination_folder = File.dirname(disk_path)
+      @client.create_datastore_folder(destination_folder, @datacenter.mob)
+    end
+  end
+end

data/lib/cloud/vsphere/file_provider.rb

@@ -1,6 +1,8 @@
+require 'cloud/vsphere/retry_block'
+
 module VSphereCloud
   class FileProvider
-    include RetryBlock
+    include VSphereCloud::RetryBlock
 
     def initialize(rest_client, vcenter_host)
       @vcenter_host = vcenter_host

data/lib/cloud/vsphere/fixed_cluster_placer.rb

@@ -7,14 +7,25 @@ module VSphereCloud
       @drs_rules = drs_rules
     end
 
-    def place(memory, ephemeral, persistent)
-      datastore = @cluster.pick_ephemeral(ephemeral)
-      if datastore
-        @cluster.allocate(memory)
-        datastore.allocate(ephemeral)
-        return [@cluster, datastore]
+    def pick_cluster_for_vm(memory, ephemeral, persistent)
+      @cluster.allocate(memory)
+      @cluster
+    end
+
+    def pick_ephemeral_datastore(cluster, disk_size_in_mb)
+      datastore = cluster.pick_ephemeral(disk_size_in_mb)
+
+      if datastore.nil?
+        raise Bosh::Clouds::NoDiskSpace.new(
+          "Not enough ephemeral disk space (#{disk_size_in_mb}MB) in cluster #{cluster.name}")
       end
-      raise "No available resources"
+
+      datastore.allocate(disk_size_in_mb)
+      datastore
+    end
+
+    def pick_persistent_datastore(_, _)
+      raise NotImplementedError
     end
   end
 end

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

@@ -19,22 +19,6 @@ module VSphereCloud
       #   @return [ResourcePool] resource pool.
       attr_reader :resource_pool
 
-      # @!attribute ephemeral_datastores
-      #   @return [Hash<String, Datastore>] ephemeral datastores.
-      attr_reader :ephemeral_datastores
-
-      # @!attribute persistent_datastores
-      #   @return [Hash<String, Datastore>] persistent datastores.
-      attr_reader :persistent_datastores
-
-      # @!attribute shared_datastores
-      #   @return [Hash<String, Datastore>] shared datastores.
-      attr_reader :shared_datastores
-
-      # @!attribute synced_free_memory
-      #   @return [Integer] cached memory utilization in MB.
-      attr_accessor :synced_free_memory
-
       # @!attribute allocated_after_sync
       #   @return [Integer] memory allocated since utilization sync in MB.
       attr_accessor :allocated_after_sync
@@ -58,19 +42,6 @@ module VSphereCloud
         @resource_pool = ResourcePool.new(cloud_config, cluster_config, properties["resourcePool"])
 
         @allocated_after_sync = 0
-        @ephemeral_datastores = {}
-        @persistent_datastores = {}
-        @shared_datastores = {}
-
-        setup_datastores
-
-        # Have to use separate mechanisms for fetching utilization depending on
-        # whether we're using resource pools or raw clusters.
-        if @config.resource_pool.nil?
-          fetch_cluster_utilization(properties['host'])
-        else
-          fetch_resource_pool_utilization
-        end
       end
 
       # Returns the persistent datastore by name. This could be either from the
@@ -79,16 +50,23 @@ module VSphereCloud
       # @param [String] datastore_name name of the datastore.
       # @return [Datastore, nil] the requested persistent datastore.
       def persistent(datastore_name)
-        @persistent_datastores[datastore_name] ||
-          @shared_datastores[datastore_name]
+        persistent_datastores[datastore_name]
       end
 
       # @return [Integer] amount of free memory in the cluster
       def free_memory
-        @synced_free_memory -
+        synced_free_memory -
           (@allocated_after_sync * cloud_config.mem_overcommit).to_i
       end
 
+      def total_free_ephemeral_disk_in_mb
+        ephemeral_datastores.values.map(&:free_space).inject(0, :+)
+      end
+
+      def total_free_persistent_disk_in_mb
+        persistent_datastores.values.map(&:free_space).inject(0, :+)
+      end
+
       # Marks the memory reservation against the cached utilization data.
       #
       # @param [Integer] memory size of memory reservation.
@@ -97,7 +75,6 @@ module VSphereCloud
         @allocated_after_sync += memory
       end
 
-
       # Picks the best datastore for the specified persistent disk.
       #
       # @param [Integer] size persistent disk size.
@@ -126,43 +103,22 @@ module VSphereCloud
         "<Cluster: #{mob} / #{config.name}>"
       end
 
-      private
-
-      attr_reader :cloud_config, :config, :client, :properties, :logger
-
-      def setup_datastores
-        datastores_properties = @client.cloud_searcher.get_properties(properties['datastore'], Vim::Datastore, Datastore::PROPERTIES)
-
-        datastores_properties.each_value do |datastore_properties|
-          name = datastore_properties["name"]
-
-          ephemeral = !!(name =~ cloud_config.datacenter_datastore_pattern)
-          persistent = !!(name =~ cloud_config.datacenter_persistent_datastore_pattern)
+      def ephemeral_datastores
+        @ephemeral_datastores ||= select_datastores(cloud_config.datacenter_datastore_pattern)
+      end
 
-          if ephemeral && persistent && !cloud_config.datacenter_allow_mixed_datastores
-            raise "Datastore patterns are not mutually exclusive: #{name}"
-          end
+      def persistent_datastores
+        @persistent_datastores ||= select_datastores(cloud_config.datacenter_persistent_datastore_pattern)
+      end
 
-          if ephemeral || persistent
-            place_datastore(datastore_properties, ephemeral, persistent)
-          end
-        end
+      private
 
-        logger.debug(
-          "Datastores - ephemeral: #{@ephemeral_datastores.keys.inspect}, " +
-            "persistent: #{@persistent_datastores.keys.inspect}, " +
-            "shared: #{@shared_datastores.keys.inspect}.")
-      end
+      attr_reader :cloud_config, :config, :client, :properties, :logger
 
-      def place_datastore(datastore_properties, ephemeral, persistent)
-        datastore = Datastore.new(datastore_properties)
-        if ephemeral && persistent
-          @shared_datastores[datastore.name] = datastore
-        elsif ephemeral
-          @ephemeral_datastores[datastore.name] = datastore
-        else
-          @persistent_datastores[datastore.name] = datastore
-        end
+      def select_datastores(pattern)
+        @datastores ||= Datastore.build_from_client(@client, properties['datastore'])
+        matching_datastores = @datastores.select { |datastore| datastore.name =~ pattern }
+        matching_datastores.inject({}) { |h, datastore| h[datastore.name] = datastore; h }
       end
 
       # Picks the best datastore for the specified disk size and type.
@@ -177,24 +133,27 @@ module VSphereCloud
       def pick_store(size, type)
         weighted_datastores = []
         datastores =
-          type == :persistent ? @persistent_datastores : @ephemeral_datastores
+          type == :persistent ? persistent_datastores : ephemeral_datastores
         datastores.each_value do |datastore|
-          if datastore.free_space - size >= DISK_THRESHOLD
+          if datastore.free_space - size >= DISK_HEADROOM
             weighted_datastores << [datastore, datastore.free_space]
           end
         end
 
-        if weighted_datastores.empty?
-          @shared_datastores.each_value do |datastore|
-            if datastore.free_space - size >= DISK_THRESHOLD
-              weighted_datastores << [datastore, datastore.free_space]
-            end
-          end
-        end
-
         Util.weighted_random(weighted_datastores)
       end
 
+      def synced_free_memory
+        return @synced_free_memory if @synced_free_memory
+        # Have to use separate mechanisms for fetching utilization depending on
+        # whether we're using resource pools or raw clusters.
+        if @config.resource_pool.nil?
+          @synced_free_memory = fetch_cluster_utilization(properties['host'])
+        else
+          @synced_free_memory = fetch_resource_pool_utilization
+        end
+      end
+
       # Fetches the raw cluster utilization from vSphere.
       #
       # First filter out any hosts that are in maintenance mode. Then aggregate
@@ -208,8 +167,8 @@ module VSphereCloud
           cluster_host_systems, Vim::HostSystem, HOST_PROPERTIES, ensure_all: true)
         active_host_mobs = select_active_host_mobs(hosts_properties)
 
-        @synced_free_memory = 0
-        return if active_host_mobs.empty?
+        synced_free_memory = 0
+        return synced_free_memory if active_host_mobs.empty?
 
         cluster_free_memory = 0
 
@@ -223,7 +182,7 @@ module VSphereCloud
           cluster_free_memory += free_memory
         end
 
-        @synced_free_memory = cluster_free_memory / BYTES_IN_MB
+        cluster_free_memory / BYTES_IN_MB
       end
 
       # Filters out the hosts that are in maintenance mode.
@@ -254,12 +213,12 @@ module VSphereCloud
 
         if runtime_info.overall_status == "green"
           memory = runtime_info.memory
-          @synced_free_memory = (memory.max_usage - memory.overall_usage) / BYTES_IN_MB
+          return (memory.max_usage - memory.overall_usage) / BYTES_IN_MB
         else
           logger.warn("Ignoring cluster: #{config.name} resource_pool: " +
                          "#{resource_pool.mob} as its state is " +
                          "unreliable: #{runtime_info.overall_status}")
-          @synced_free_memory = 0
+          return 0
         end
       end
     end

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

@@ -7,6 +7,7 @@ module VSphereCloud
 
       def initialize(config)
         @config = config
+        @client = config.client
       end
 
       def mob
@@ -24,6 +25,10 @@ module VSphereCloud
         end
       end
 
+      def vm_path(vm_cid)
+        [name, 'vm', vm_folder.path_components, vm_cid].join('/')
+      end
+
       def master_vm_folder
         Folder.new(@config.datacenter_vm_folder, @config)
       end
@@ -57,22 +62,14 @@ module VSphereCloud
         @config.datacenter_persistent_datastore_pattern
       end
 
-      def allow_mixed
-        @config.datacenter_allow_mixed_datastores
-      end
-
       def inspect
         "<Datacenter: #{mob} / #{name}>"
       end
 
       def clusters
-        client = @config.client
-        cluster_mobs = client.cloud_searcher.get_managed_objects(
-          Vim::ClusterComputeResource, root: mob, include_name: true)
-        cluster_mobs.delete_if { |name, _| !config.datacenter_clusters.has_key?(name) }
-        cluster_mobs = Hash[*cluster_mobs.flatten]
+        cluster_mobs = Hash[*cluster_tuples.flatten]
 
-        clusters_properties = client.cloud_searcher.get_properties(
+        clusters_properties = @client.cloud_searcher.get_properties(
           cluster_mobs.values, Vim::ClusterComputeResource,
           Cluster::PROPERTIES, :ensure_all => true)
 
@@ -89,6 +86,36 @@ module VSphereCloud
         end
         clusters
       end
+
+      def persistent_datastores
+        datastores = {}
+        clusters.each do |_, cluster|
+          cluster.persistent_datastores.each do |_, datastore|
+            datastores[datastore.name] = datastore
+          end
+        end
+        datastores
+      end
+
+      def pick_persistent_datastore(disk_size_in_mb)
+        weighted_datastores = []
+        persistent_datastores.each_value do |datastore|
+          if datastore.free_space - disk_size_in_mb >= DISK_HEADROOM
+            weighted_datastores << [datastore, datastore.free_space]
+          end
+        end
+
+        Util.weighted_random(weighted_datastores)
+      end
+
+      private
+
+      def cluster_tuples
+        cluster_tuples = @client.cloud_searcher.get_managed_objects(
+          Vim::ClusterComputeResource, root: mob, include_name: true)
+        cluster_tuples.delete_if { |name, _| !config.datacenter_clusters.has_key?(name) }
+        cluster_tuples
+      end
     end
   end
 end

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

@@ -1,18 +1,29 @@
 module VSphereCloud
   class Resources
-
-    # Datastore resource.
     class Datastore
+      include VimSdk
       PROPERTIES = %w(summary.freeSpace summary.capacity name)
 
-      # @!attribute mob
-      #   @return [Vim::Datastore] datastore vSphere MOB.
-      attr_accessor :mob
+      def self.build_from_client(client, datastore_properties)
+        ds_properties_map = client.cloud_searcher.get_properties(datastore_properties, Vim::Datastore, Datastore::PROPERTIES)
+        ds_properties_map.values.map do |ds_properties|
+          Datastore.new(
+            ds_properties['name'],
+            ds_properties[:obj],
+            ds_properties['summary.capacity'].to_i / BYTES_IN_MB,
+            ds_properties['summary.freeSpace'].to_i / BYTES_IN_MB,
+          )
+        end
+      end
 
       # @!attribute name
       #   @return [String] datastore name.
       attr_accessor :name
 
+      # @!attribute mob
+      #   @return [Vim::Datastore] datastore vSphere MOB.
+      attr_accessor :mob
+
       # @!attribute total_space
       #   @return [Integer] datastore capacity.
       attr_accessor :total_space
@@ -29,11 +40,11 @@ module VSphereCloud
       #
       # @param [Hash] properties prefetched vSphere properties to build the
       #   model.
-      def initialize(properties)
-        @mob = properties[:obj]
-        @name = properties["name"]
-        @total_space = properties["summary.capacity"].to_i / BYTES_IN_MB
-        @synced_free_space = properties["summary.freeSpace"].to_i / BYTES_IN_MB
+      def initialize(name, mob, total_space, synced_free_space)
+        @name = name
+        @mob = mob
+        @total_space = total_space
+        @synced_free_space = synced_free_space
         @allocated_after_sync = 0
       end
 

data/lib/cloud/vsphere/resources/disk/disk_config.rb

@@ -1,15 +1,15 @@
 module VSphereCloud
   class DiskConfig
-    def initialize(datastore, filename, controller_key, size)
-      @datastore = datastore
+    def initialize(datastore_name, filename, controller_key, size_in_mb)
+      @datastore_name = datastore_name
       @filename = filename
       @controller_key = controller_key
-      @size = size
+      @size_in_mb = size_in_mb
     end
 
     def spec(options)
       backing_info = VimSdk::Vim::Vm::Device::VirtualDisk::FlatVer2BackingInfo.new
-      backing_info.datastore = @datastore
+      backing_info.datastore = @datastore_name
       if options[:independent]
         backing_info.disk_mode = VimSdk::Vim::Vm::Device::VirtualDiskOption::DiskMode::INDEPENDENT_PERSISTENT
       else
@@ -21,7 +21,7 @@ module VSphereCloud
       virtual_disk.key = -1
       virtual_disk.controller_key = @controller_key
       virtual_disk.backing = backing_info
-      virtual_disk.capacity_in_kb = @size * 1024
+      virtual_disk.capacity_in_kb = @size_in_mb * 1024
 
       device_config_spec = VimSdk::Vim::Vm::Device::VirtualDeviceSpec.new
       device_config_spec.device = virtual_disk

data/lib/cloud/vsphere/resources/disk/ephemeral_disk.rb

@@ -2,14 +2,14 @@ require 'cloud/vsphere/resources/disk/disk_config'
 
 module VSphereCloud
   class EphemeralDisk
-    def initialize(size, folder_name, datastore)
+    def initialize(size_in_mb, folder_name, datastore)
       @folder_name = folder_name
       @datastore = datastore
-      @size = size
+      @size_in_mb = size_in_mb
     end
 
     def create_spec(controller_key)
-      DiskConfig.new(@datastore.mob, filename, controller_key, @size).spec(create: true)
+      DiskConfig.new(@datastore.mob, filename, controller_key, @size_in_mb).spec(create: true)
     end
 
     private

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

@@ -0,0 +1,19 @@
+module VSphereCloud
+  class Resources
+    class Disk
+      attr_reader :datastore, :size_in_mb, :path, :cid
+
+      def initialize(cid, size_in_mb, datastore, path)
+        @cid = cid
+        @size_in_mb = size_in_mb
+        @datastore = datastore
+        @path = path
+      end
+
+      def attach_spec(controller_key)
+        DiskConfig.new(datastore.name, path, controller_key, size_in_mb).
+          spec(independent: true)
+      end
+    end
+  end
+end

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

@@ -3,32 +3,37 @@ module VSphereCloud
     class ResourcePool
       include VimSdk
 
-      # @!attribute mob
-      #   @return [Vim::ResourcePool] resource pool vSphere MOB.
-      attr_accessor :mob
-
       # Creates a new ResourcePool resource.
       #
       # @param [Cluster] cluster parent cluster.
       # @param [Vim::ResourcePool] root_resource_pool cluster's root resource
       #   pool.
       def initialize(cloud_config, cluster_config, root_resource_pool)
-        if cluster_config.resource_pool.nil?
-          @mob = root_resource_pool
+        @cloud_config = cloud_config
+        @cluster_config = cluster_config
+        @root_resource_pool = root_resource_pool
+      end
+
+      def mob
+        return @mob if @mob
+
+        if @cluster_config.resource_pool.nil?
+          @mob = @root_resource_pool
         else
-          client = cloud_config.client
-          logger = cloud_config.logger
+          client = @cloud_config.client
+          logger = @cloud_config.logger
           @mob = client.cloud_searcher.get_managed_object(
-              Vim::ResourcePool,
-              :root => root_resource_pool,
-              :name => cluster_config.resource_pool)
-          logger.debug("Found requested resource pool: #@mob")
+            Vim::ResourcePool,
+            :root => @root_resource_pool,
+            :name => @cluster_config.resource_pool)
+          logger.debug("Found requested resource pool: #{@mob}")
         end
+        @mob
       end
 
       # @return [String] debug resource pool information.
       def inspect
-        "<Resource Pool: #@mob>"
+        "<Resource Pool: #{mob}>"
       end
     end
   end