bosh_vsphere_cpi 1.1868.0 → 1.1975.0

data/lib/cloud/vsphere/fixed_cluster_placer.rb

@@ -0,0 +1,17 @@
+module VSphereCloud
+  class FixedClusterPlacer
+    def initialize(cluster)
+      @cluster = cluster
+    end
+
+    def place(memory, ephemeral, persistent)
+      datastore = @cluster.pick_ephemeral(ephemeral)
+      if datastore
+        @cluster.allocate(memory)
+        datastore.allocate(ephemeral)
+        return [@cluster, datastore]
+      end
+      raise "No available resources"
+    end
+  end
+end

data/lib/cloud/vsphere/resources.rb

@@ -1,18 +1,15 @@
-# Copyright (c) 2009-2012 VMware, Inc.
+require 'cloud/vsphere/resources/datacenter'
 
 module VSphereCloud
-
-  # Resources model.
   class Resources
     MEMORY_THRESHOLD = 128
     DISK_THRESHOLD = 1024
     STALE_TIMEOUT = 60
     BYTES_IN_MB = 1024 * 1024
 
-    # Creates a new resources model.
-    def initialize
-      @client = Config.client
-      @logger = Config.logger
+    def initialize(config)
+      @config = config
+      @logger = config.logger
       @last_update = 0
       @lock = Monitor.new
     end
@@ -100,7 +97,7 @@ module VSphereCloud
         locality.each do |cluster, _|
           persistent_sizes = persistent_sizes_for_cluster(cluster, persistent)
 
-          scorer = Scorer.new(cluster, memory, ephemeral, persistent_sizes)
+          scorer = Scorer.new(@config, cluster, memory, ephemeral, persistent_sizes)
           if scorer.score > 0
             datastore = cluster.pick_ephemeral(ephemeral)
             if datastore
@@ -113,23 +110,23 @@ module VSphereCloud
 
         unless locality.empty?
           @logger.debug("Ignoring datastore locality as we could not find " +
-                            "any resources near disks: #{persistent.inspect}")
+                          "any resources near disks: #{persistent.inspect}")
         end
 
         weighted_clusters = []
-        datacenters.each_value do |datacenter|
-          datacenter.clusters.each_value do |cluster|
-            persistent_sizes = persistent_sizes_for_cluster(cluster, persistent)
-            scorer = Scorer.new(cluster, memory, ephemeral, persistent_sizes)
-            score = scorer.score
-            @logger.debug("Score: #{cluster.name}: #{score}")
-            weighted_clusters << [cluster, score] if score > 0
-          end
+        datacenter = datacenters.first.last
+        datacenter.clusters.each_value do |cluster|
+          persistent_sizes = persistent_sizes_for_cluster(cluster, persistent)
+          scorer = Scorer.new(@config, cluster, memory, ephemeral, persistent_sizes)
+          score = scorer.score
+          @logger.debug("Score: #{cluster.name}: #{score}")
+          weighted_clusters << [cluster, score] if score > 0
         end
 
         raise "No available resources" if weighted_clusters.empty?
 
         cluster = Util.weighted_random(weighted_clusters)
+
         datastore = cluster.pick_ephemeral(ephemeral)
 
         if datastore
@@ -144,13 +141,14 @@ module VSphereCloud
 
     private
 
+    attr_reader :config
+
     # Updates the resource models from vSphere.
     # @return [void]
     def update
-      @datacenters = {}
-      Config.vcenter.datacenters.each_value do |config|
-        @datacenters[config.name] = Datacenter.new(config)
-      end
+      #datacenter_config = config.vcenter_datacenter
+      datacenter = Datacenter.new(config)
+      @datacenters = { datacenter.name => datacenter }
       @last_update = Time.now.to_i
     end
 
@@ -212,7 +210,7 @@ module VSphereCloud
     # @return [Array<Hash>] filtered out disk specs.
     def persistent_sizes_for_cluster(cluster, disks)
       disks.select { |disk| disk[:cluster] != cluster }.
-          collect { |disk| disk[:size] }
+        collect { |disk| disk[:size] }
     end
   end
 end

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

@@ -1,51 +1,35 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
 module VSphereCloud
   class Resources
-
-    # Cluster resource.
     class Cluster
       include VimSdk
 
       PROPERTIES = %w(name datastore resourcePool host)
       HOST_PROPERTIES = %w(hardware.memorySize runtime.inMaintenanceMode)
-      HOST_COUNTERS = %w(cpu.usage.average mem.usage.average)
+      HOST_COUNTERS = %w(mem.usage.average)
 
       # @!attribute mob
       #   @return [Vim::ClusterComputeResource] cluster vSphere MOB.
-      attr_accessor :mob
-
-      # @!attribute config
-      #   @return [ClusterConfig] cluster config.
-      attr_accessor :config
+      attr_reader :mob
 
       # @!attribute datacenter
       #   @return [Datacenter] parent datacenter.
-      attr_accessor :datacenter
+      attr_reader :datacenter
 
       # @!attribute resource_pool
       #   @return [ResourcePool] resource pool.
-      attr_accessor :resource_pool
+      attr_reader :resource_pool
 
       # @!attribute ephemeral_datastores
       #   @return [Hash<String, Datastore>] ephemeral datastores.
-      attr_accessor :ephemeral_datastores
+      attr_reader :ephemeral_datastores
 
       # @!attribute persistent_datastores
       #   @return [Hash<String, Datastore>] persistent datastores.
-      attr_accessor :persistent_datastores
+      attr_reader :persistent_datastores
 
       # @!attribute shared_datastores
       #   @return [Hash<String, Datastore>] shared datastores.
-      attr_accessor :shared_datastores
-
-      # @!attribute idle_cpu
-      #   @return [Float] idle cpu ratio.
-      attr_accessor :idle_cpu
-
-      # @!attribute total_memory
-      #   @return [Integer] memory capacity in MB.
-      attr_accessor :total_memory
+      attr_reader :shared_datastores
 
       # @!attribute synced_free_memory
       #   @return [Integer] cached memory utilization in MB.
@@ -58,60 +42,34 @@ module VSphereCloud
       # Creates a new Cluster resource from the specified datacenter, cluster
       # configuration, and prefetched properties.
       #
-      # @param [Datacenter] datacenter parent datacenter.
+      # @param [CloudConfig] VSphereCloud::Config
       # @param [ClusterConfig] config cluster configuration as specified by the
       #   operator.
       # @param [Hash] properties prefetched vSphere properties for the cluster.
-      def initialize(datacenter, config, properties)
-        @logger = Config.logger
-        @client = Config.client
-
+      def initialize(datacenter, cloud_config, cluster_config, properties)
         @datacenter = datacenter
-        @config = config
-        @mob = properties[:obj]
-        @resource_pool = ResourcePool.new(self, properties["resourcePool"])
+        @logger = cloud_config.logger
+        @client = cloud_config.client
+        @properties = properties
+
+        @config = cluster_config
+        @cloud_config = cloud_config
+        @mob = properties['obj']
+        @resource_pool = ResourcePool.new(cloud_config, cluster_config, properties["resourcePool"])
 
         @allocated_after_sync = 0
         @ephemeral_datastores = {}
         @persistent_datastores = {}
         @shared_datastores = {}
 
-        datastores_properties = @client.get_properties(
-            properties["datastore"], Vim::Datastore, Datastore::PROPERTIES)
-        datastores_properties.each_value do |datastore_properties|
-          name = datastore_properties["name"]
-          datastore_config = datacenter.config.datastores
-          ephemeral = !!(name =~ datastore_config.ephemeral_pattern)
-          persistent = !!(name =~ datastore_config.persistent_pattern)
-
-          if ephemeral && persistent &&
-              !datastore_config.allow_mixed
-            raise "Datastore patterns are not mutually exclusive: #{name}"
-          end
-
-          if 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
-          end
-        end
-
-        @logger.debug(
-            "Datastores - ephemeral: #{@ephemeral_datastores.keys.inspect}, " +
-                "persistent: #{@persistent_datastores.keys.inspect}, " +
-                "shared: #{@shared_datastores.keys.inspect}.")
+        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"])
+          fetch_cluster_utilization(properties['host'])
         else
-          fetch_res_pool_utilization
+          fetch_resource_pool_utilization
         end
       end
 
@@ -122,15 +80,24 @@ module VSphereCloud
       # @return [Datastore, nil] the requested persistent datastore.
       def persistent(datastore_name)
         @persistent_datastores[datastore_name] ||
-            @shared_datastores[datastore_name]
+          @shared_datastores[datastore_name]
       end
 
       # @return [Integer] amount of free memory in the cluster
       def free_memory
         @synced_free_memory -
-            (@allocated_after_sync * Config.mem_overcommit).to_i
+          (@allocated_after_sync * cloud_config.mem_overcommit).to_i
       end
 
+      # Marks the memory reservation against the cached utilization data.
+      #
+      # @param [Integer] memory size of memory reservation.
+      # @return [void]
+      def allocate(memory)
+        @allocated_after_sync += memory
+      end
+
+
       # Picks the best datastore for the specified persistent disk.
       #
       # @param [Integer] size persistent disk size.
@@ -149,26 +116,55 @@ module VSphereCloud
         pick_store(size, :ephemeral)
       end
 
-      # Marks the memory reservation against the cached utilization data.
-      #
-      # @param [Integer] memory size of memory reservation.
-      # @return [void]
-      def allocate(memory)
-        @allocated_after_sync += memory
-      end
-
       # @return [String] cluster name.
       def name
-        @config.name
+        config.name
       end
 
       # @return [String] debug cluster information.
       def inspect
-        "<Cluster: #@mob / #{@config.name}>"
+        "<Cluster: #{mob} / #{config.name}>"
       end
 
       private
 
+      attr_reader :cloud_config, :config, :client, :properties, :logger
+
+      def setup_datastores
+        datastores_properties = client.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)
+
+          if ephemeral && persistent && !cloud_config.datacenter_allow_mixed_datastores
+            raise "Datastore patterns are not mutually exclusive: #{name}"
+          end
+
+          if ephemeral || persistent
+            place_datastore(datastore_properties, ephemeral, persistent)
+          end
+        end
+
+        logger.debug(
+          "Datastores - ephemeral: #{@ephemeral_datastores.keys.inspect}, " +
+            "persistent: #{@persistent_datastores.keys.inspect}, " +
+            "shared: #{@shared_datastores.keys.inspect}.")
+      end
+
+      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
+      end
+
       # Picks the best datastore for the specified disk size and type.
       #
       # First the exclusive datastore pool is used. If it's empty or doesn't
@@ -181,7 +177,7 @@ 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
             weighted_datastores << [datastore, datastore.free_space]
@@ -205,45 +201,42 @@ module VSphereCloud
       # individual host capacity and its utilization using the performance
       # manager.
       #
-      # @param [Array<Vim::HostSystem>] host_mobs cluster hosts.
+      # @param [Array<Vim::HostSystem>] cluster_host_systems cluster hosts.
       # @return [void]
-      def fetch_cluster_utilization(host_mobs)
+      def fetch_cluster_utilization(cluster_host_systems)
         hosts_properties = @client.get_properties(
-            host_mobs, Vim::HostSystem, HOST_PROPERTIES, :ensure_all => true)
-        host_mobs = filter_inactive_hosts(hosts_properties)
+          cluster_host_systems, Vim::HostSystem, HOST_PROPERTIES, ensure_all: true)
+        active_host_mobs = select_active_host_mobs(hosts_properties)
 
-        if host_mobs.empty?
-          @idle_cpu = 0
-          @total_memory = 0
-          @synced_free_memory = 0
-          return
-        end
+        @synced_free_memory = 0
+        return if active_host_mobs.empty?
 
-        samples = 0
-        cluster_total_memory = 0
         cluster_free_memory = 0
-        cluster_cpu_usage = 0
 
-        counters = @client.get_perf_counters(
-            host_mobs, HOST_COUNTERS, :max_sample => 5)
+        counters = @client.get_perf_counters(active_host_mobs, HOST_COUNTERS, max_sample: 5)
         counters.each do |host_mob, counter|
           host_properties = hosts_properties[host_mob]
           total_memory = host_properties["hardware.memorySize"].to_i
           percent_used = Util.average_csv(counter["mem.usage.average"]) / 10000
           free_memory = ((1.0 - percent_used) * total_memory).to_i
 
-          samples += 1
-          cluster_total_memory += total_memory
           cluster_free_memory += free_memory
-          cluster_cpu_usage +=
-              Util.average_csv(counter["cpu.usage.average"]) / 100
         end
 
-        @idle_cpu = (100 - cluster_cpu_usage / samples) / 100
-        @total_memory = cluster_total_memory / BYTES_IN_MB
         @synced_free_memory = cluster_free_memory / BYTES_IN_MB
       end
 
+      # Filters out the hosts that are in maintenance mode.
+      #
+      # @param [Hash] host_properties host properties that already fetched
+      #   inMaintenanceMode from vSphere.
+      # @return [Array<Vim::HostSystem>] list of hosts that are active
+      def select_active_host_mobs(host_properties)
+        host_properties.values.
+          select { |p| p['runtime.inMaintenanceMode'] != 'true' }.
+          collect { |p| p['obj'] }
+      end
+
       # Fetches the resource pool utilization from vSphere.
       #
       # We can only rely on the vSphere data if the resource pool is healthy.
@@ -253,42 +246,22 @@ module VSphereCloud
       # so we can't use it for the raw clusters.
       #
       # @return [void]
-      def fetch_res_pool_utilization
-        properties = @client.get_properties(
-            @resource_pool.mob, Vim::ResourcePool, %w(summary))
-        if properties.nil?
-          raise "Failed to get utilization for resource pool #{resource_pool}"
-        end
+      def fetch_resource_pool_utilization
+        properties = @client.get_properties(resource_pool.mob, Vim::ResourcePool, 'summary')
+        raise "Failed to get utilization for resource pool #{resource_pool}" if properties.nil?
 
         runtime_info = properties["summary"].runtime
+
         if runtime_info.overall_status == "green"
-          cpu = runtime_info.cpu
-          @idle_cpu = 1 - (cpu.overall_usage.to_f / cpu.max_usage)
           memory = runtime_info.memory
-          @total_memory = memory.max_usage / BYTES_IN_MB
-          @synced_free_memory =
-              (memory.max_usage - memory.overall_usage) / BYTES_IN_MB
+          @synced_free_memory = (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}")
-          # resource pool is in an unreliable state
-          @idle_cpu = 0
-          @total_memory = 0
+          logger.warn("Ignoring cluster: #{config.name} resource_pool: " +
+                         "#{resource_pool.mob} as its state is " +
+                         "unreliable: #{runtime_info.overall_status}")
           @synced_free_memory = 0
         end
       end
-
-      # Filters out the hosts that are in maintenance mode.
-      #
-      # @param [Hash] host_properties host properties that already fetched
-      #   inMaintenanceMode from vSphere.
-      # @return [Array<Vim::HostSystem>] list of hosts that are active
-      def filter_inactive_hosts(host_properties)
-        host_properties.values.
-            select { |p| p["runtime.inMaintenanceMode"] != "true" }.
-            collect { |p| p[:obj] }
-      end
     end
   end
-end
+end