bosh_vsphere_cpi 1.1868.0 → 1.1975.0

data/lib/cloud/vsphere/client.rb

@@ -10,7 +10,7 @@ module VSphereCloud
     class NotLoggedInException < StandardError; end
 
     attr_accessor :service_content
-    attr_accessor :stub
+    attr_accessor :soap_stub
     attr_accessor :service_instance
 
     def initialize(host, options = {})
@@ -26,9 +26,9 @@ module VSphereCloud
       http_client.connect_timeout = 4
       http_client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
 
-      @stub = Soap::StubAdapter.new(host, "vim.version.version6", http_client)
+      @soap_stub = Soap::StubAdapter.new(host, "vim.version.version6", http_client)
 
-      @service_instance = Vim::ServiceInstance.new("ServiceInstance", stub)
+      @service_instance = Vim::ServiceInstance.new("ServiceInstance", soap_stub)
       @service_content = service_instance.content
       @metrics_cache  = {}
       @lock = Mutex.new

data/lib/cloud/vsphere/cloud.rb

@@ -16,6 +16,8 @@ require 'cloud/vsphere/resources/scorer'
 require 'cloud/vsphere/resources/util'
 require 'cloud/vsphere/models/disk'
 require 'cloud/vsphere/path_finder'
+require 'cloud/vsphere/vm_creator_builder'
+require 'cloud/vsphere/fixed_cluster_placer'
 
 module VSphereCloud
 
@@ -28,12 +30,12 @@ module VSphereCloud
     attr_accessor :client
 
     def initialize(options)
-      Config.configure(options)
+      @config = Config.build(options)
 
-      @logger = Config.logger
-      @client = Config.client
-      @rest_client = Config.rest_client
-      @resources = Resources.new
+      @logger = config.logger
+      @client = config.client
+      @rest_client = config.rest_client
+      @resources = Resources.new(config)
 
       # Global lock
       @lock = Mutex.new
@@ -163,108 +165,10 @@ module VSphereCloud
       client.find_by_inventory_path([dc.name, 'vm', dc.template_folder.name, name])
     end
 
-    def create_vm(agent_id, stemcell, resource_pool, networks, disk_locality = nil, environment = nil)
+    def create_vm(agent_id, stemcell, cloud_properties, networks, disk_locality = nil, environment = nil)
       with_thread_name("create_vm(#{agent_id}, ...)") do
-        memory = resource_pool['ram']
-        disk = resource_pool['disk']
-        cpu = resource_pool['cpu']
-
-        # Make sure number of cores is a power of 2. kb.vmware.com/kb/2003484
-        if cpu & cpu - 1 != 0
-          raise "Number of vCPUs: #{cpu} is not a power of 2."
-        end
-
-        stemcell_vm = stemcell_vm(stemcell)
-        raise "Could not find stemcell: #{stemcell}" if stemcell_vm.nil?
-
-        stemcell_size =
-          client.get_property(stemcell_vm, Vim::VirtualMachine, 'summary.storage.committed', ensure_all: true)
-        stemcell_size /= 1024 * 1024
-
-        disks = disk_spec(disk_locality)
-        # need to include swap and linked clone log
-        ephemeral = disk + memory + stemcell_size
-        cluster, datastore = @resources.place(memory, ephemeral, disks)
-
-        name = "vm-#{generate_unique_name}"
-        @logger.info("Creating vm: #{name} on #{cluster.mob} stored in #{datastore.mob}")
-
-        replicated_stemcell_vm = replicate_stemcell(cluster, datastore, stemcell)
-        replicated_stemcell_properties = client.get_properties(replicated_stemcell_vm, Vim::VirtualMachine,
-                                                               ['config.hardware.device', 'snapshot'],
-                                                               ensure_all: true)
-
-        devices = replicated_stemcell_properties['config.hardware.device']
-        snapshot = replicated_stemcell_properties['snapshot']
-
-        config = Vim::Vm::ConfigSpec.new(memory_mb: memory, num_cpus: cpu)
-        config.device_change = []
-
-        system_disk = devices.find { |device| device.kind_of?(Vim::Vm::Device::VirtualDisk) }
-        pci_controller = devices.find { |device| device.kind_of?(Vim::Vm::Device::VirtualPCIController) }
-
-        file_name = "[#{datastore.name}] #{name}/ephemeral_disk.vmdk"
-        ephemeral_disk_config =
-          create_disk_config_spec(datastore.mob, file_name, system_disk.controller_key, disk, create: true)
-        config.device_change << ephemeral_disk_config
-
-        dvs_index = {}
-        networks.each_value do |network|
-          v_network_name = network['cloud_properties']['name']
-          network_mob = client.find_by_inventory_path([cluster.datacenter.name, 'network', v_network_name])
-          nic_config = create_nic_config_spec(v_network_name, network_mob, pci_controller.key, dvs_index)
-          config.device_change << nic_config
-        end
-
-        nics = devices.select { |device| device.kind_of?(Vim::Vm::Device::VirtualEthernetCard) }
-        nics.each do |nic|
-          nic_config = create_delete_device_spec(nic)
-          config.device_change << nic_config
-        end
-
-        fix_device_unit_numbers(devices, config.device_change)
-
-        @logger.info("Cloning vm: #{replicated_stemcell_vm} to #{name}")
-
-        task = clone_vm(replicated_stemcell_vm,
-                        name,
-                        cluster.datacenter.vm_folder.mob,
-                        cluster.resource_pool.mob,
-                        datastore: datastore.mob, linked: true, snapshot: snapshot.current_snapshot, config: config)
-        vm = client.wait_for_task(task)
-
-        begin
-          upload_file(cluster.datacenter.name, datastore.name, "#{name}/env.iso", '')
-
-          vm_properties = client.get_properties(vm, Vim::VirtualMachine, ['config.hardware.device'], ensure_all: true)
-          devices = vm_properties['config.hardware.device']
-
-          # Configure the ENV CDROM
-          config = Vim::Vm::ConfigSpec.new
-          config.device_change = []
-          file_name = "[#{datastore.name}] #{name}/env.iso"
-          cdrom_change = configure_env_cdrom(datastore.mob, devices, file_name)
-          config.device_change << cdrom_change
-          client.reconfig_vm(vm, config)
-
-          network_env = generate_network_env(devices, networks, dvs_index)
-          disk_env = generate_disk_env(system_disk, ephemeral_disk_config.device)
-          env = generate_agent_env(name, vm, agent_id, network_env, disk_env)
-          env['env'] = environment
-          @logger.info("Setting VM env: #{env.pretty_inspect}")
-
-          location =
-            get_vm_location(vm, datacenter: cluster.datacenter.name, datastore: datastore.name, vm: name)
-          set_agent_env(vm, location, env)
-
-          @logger.info("Powering on VM: #{vm} (#{name})")
-          client.power_on_vm(cluster.datacenter.mob, vm)
-        rescue => e
-          @logger.info("#{e} - #{e.backtrace.join("\n")}")
-          delete_vm(name)
-          raise e
-        end
-        name
+        VmCreatorBuilder.new.build(choose_placer(cloud_properties), cloud_properties, @client, @logger, self).
+          create(agent_id, stemcell, networks, disk_locality, environment)
       end
     end
 
@@ -541,7 +445,7 @@ module VSphereCloud
             destination_path = "[#{persistent_datastore.name}] #{datacenter_disk_path}/#{disk.uuid}"
             @logger.info("Moving #{disk.datacenter}/#{source_path} to #{datacenter_name}/#{destination_path}")
 
-            if Config.copy_disks
+            if config.copy_disks
               client.copy_disk(source_datacenter, source_path, datacenter, destination_path)
               @logger.info('Copied disk successfully')
             else
@@ -790,7 +694,7 @@ module VSphereCloud
       env['agent_id'] = agent_id
       env['networks'] = networking_env
       env['disks'] = disk_env
-      env.merge!(Config.agent)
+      env.merge!(config.agent)
       env
     end
 
@@ -906,7 +810,7 @@ module VSphereCloud
     def fetch_file(datacenter_name, datastore_name, path)
       retry_block do
         url =
-          "https://#{Config.vcenter.host}/folder/#{path}?dcPath=#{URI.escape(datacenter_name)}&dsName=#{URI.escape(datastore_name)}"
+          "https://#{config.vcenter_host}/folder/#{path}?dcPath=#{URI.escape(datacenter_name)}&dsName=#{URI.escape(datastore_name)}"
 
         response = @rest_client.get(url)
 
@@ -923,7 +827,7 @@ module VSphereCloud
     def upload_file(datacenter_name, datastore_name, path, contents)
       retry_block do
         url =
-          "https://#{Config.vcenter.host}/folder/#{path}?dcPath=#{URI.escape(datacenter_name)}&dsName=#{URI.escape(datastore_name)}"
+          "https://#{config.vcenter_host}/folder/#{path}?dcPath=#{URI.escape(datacenter_name)}&dsName=#{URI.escape(datastore_name)}"
         response = @rest_client.put(url,
                                     contents,
                                     { 'Content-Type' => 'application/octet-stream', 'Content-Length' => contents.length })
@@ -1143,5 +1047,22 @@ module VSphereCloud
 
       vms
     end
+
+    private
+
+    def choose_placer(cloud_properties)
+      datacenter_spec = cloud_properties.fetch('datacenters', []).first
+      cluster_spec = datacenter_spec.fetch('clusters', []).first if datacenter_spec
+      placer = FixedClusterPlacer.new(find_cluster(cluster_spec)) unless cluster_spec.nil?
+
+      placer.nil? ? @resources : placer
+    end
+
+    def find_cluster(cluster_spec)
+      datacenter = Resources::Datacenter.new(config)
+      datacenter.clusters[cluster_spec.keys.first]
+    end
+
+    attr_reader :config
   end
 end

data/lib/cloud/vsphere/cluster_config.rb

@@ -0,0 +1,15 @@
+module VSphereCloud
+  class ClusterConfig
+
+    attr_reader :name
+
+    def initialize(name, config_hash)
+      @name = name
+      @config = config_hash
+    end
+
+    def resource_pool
+      @config['resource_pool']
+    end
+  end
+end

data/lib/cloud/vsphere/config.rb

@@ -1,250 +1,192 @@
-# Copyright (c) 2009-2012 VMware, Inc.
+require 'cloud/vsphere/cluster_config'
 
 module VSphereCloud
-
-  # vSphere CPI Config
   class Config
-
-    # Membrane schema for the provided config.
-    @schema = Membrane::SchemaParser.parse do
-        {
-            "agent" => dict(String, Object), # passthrough to the agent
-            optional("cpi_log") => String,
-            optional("soap_log") => String,
-            optional("mem_overcommit_ratio") => Numeric,
-            optional("copy_disks") => bool,
-            "vcenters" => [{
-              "host" => String,
-              "user" => String,
-              "password" => String,
-              "datacenters" => [{
-                "name" => String,
-                "vm_folder" => String,
-                "template_folder" => String,
-                optional("use_sub_folder") => bool,
-                "disk_path" => String,
-                "datastore_pattern" => String,
-                "persistent_datastore_pattern" => String,
-                optional("allow_mixed_datastores") => bool,
-                "clusters" => [enum(String,
-                                   dict(String, {"resource_pool" => String}))]
-              }]
-            }]
-        }
+    def self.build(config_hash)
+      config = new(config_hash)
+      config.validate
+      config
     end
 
-    # vCenter config.
-    class VCenterConfig
+    def initialize(config_hash)
+      @config = config_hash
+      @vcenter_host = nil
+      @vcenter_user = nil
+      @vcenter_password = nil
+      @rest_client = nil
+      @default_overcommit_ratio = 1.0
 
-      # @!attribute host
-      #   @return [String] vCenter host.
-      attr_accessor :host
+      @is_validated = false
+    end
 
-      # @!attribute user
-      #   @return [String] vCenter user.
-      attr_accessor :user
+    def validate
+      return true if @is_validated
 
-      # @!attribute password
-      #   @return [String] vCenter password.
-      attr_accessor :password
+      unless config['vcenters'].size == 1
+        raise 'vSphere CPI only supports a single vCenter'
+      end
 
-      # @!attribute datacenters
-      #   @return [Hash<String, DatacenterConfig>] child datacenters.
-      attr_accessor :datacenters
+      unless config['vcenters'].first['datacenters'].size ==1
+        raise 'vSphere CPI only supports a single datacenter'
+      end
 
-      # Creates a new vCenter Config model from parsed YAML.
-      #
-      # @param [Hash] config parsed YAML.
-      def initialize(config)
-        @host = config["host"]
-        @user = config["user"]
-        @password = config["password"]
-        @datacenters = {}
+      validate_schema
 
-        unless config["datacenters"].size == 1
-          raise "vSphere CPI only supports a single datacenter."
-        end
+      @is_validated = true
+    end
 
-        config["datacenters"].each do |dc|
-          dc_config = DatacenterConfig.new(dc)
-          @datacenters[dc_config.name] = dc_config
-        end
-      end
+    def logger
+      @logger ||= Bosh::Clouds::Config.logger
     end
 
-    # Folder config.
-    class FolderConfig
-      # @!attribute vm
-      #   @return [String] vm folder path.
-      attr_accessor :vm
+    def client
+      unless @client
+        @client = Client.new("https://#{vcenter['host']}/sdk/vimService", {
+          'soap_log' => config['soap_log'] || config['cpi_log']
+        })
 
-      # @!attribute template
-      #   @return [String] template/stemcell folder path.
-      attr_accessor :template
+        @client.login(vcenter['user'], vcenter['password'], 'en')
+      end
 
-      # @!attribute shared
-      #   @return [true, false] boolean indicating shared folders, so an
-      #     additional namespace should be used.
-      attr_accessor :shared
+      @client
     end
 
-    # Datastore config.
-    class DatastoreConfig
-
-      # @!attribute ephemeral_pattern
-      #   @return [Regexp] regexp pattern for ephemeral datastores.
-      attr_accessor :ephemeral_pattern
-
-      # @!attribute persistent_pattern
-      #   @return [Regexp] regexp pattern for persistent datastores.
-      attr_accessor :persistent_pattern
+    def rest_client
+      unless @rest_client
+        @rest_client = HTTPClient.new
+        @rest_client.send_timeout = 14400 # 4 hours, for stemcell uploads
+        @rest_client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
 
-      # @!attribute disk_path
-      #   @return [String] VMDK datastore path.
-      attr_accessor :disk_path
+        # HACK: read the session from the SOAP client so we don't leak sessions
+        # when using the REST client
+        cookie_str = client.soap_stub.cookie
+        @rest_client.cookie_manager.parse(cookie_str, URI.parse("https://#{vcenter_host}"))
+      end
 
-      # @!attribute allow_mixed
-      #   @return [true, false] boolean indicating whether persistent and
-      #     ephemeral datastores can overlap..
-      attr_accessor :allow_mixed
+      @rest_client
     end
 
-    # Datacenter config.
-    class DatacenterConfig
-
-      # @!attribute name
-      #   @return [String] datacenter name.
-      attr_accessor :name
+    def mem_overcommit
+      config.fetch('mem_overcommit_ratio', @default_overcommit_ratio)
+    end
 
-      # @!attribute folders
-      #   @return [FolderConfig] folder config.
-      attr_accessor :folders
+    def copy_disks
+      !!config['copy_disks']
+    end
 
-      # @!attribute datastores
-      #   @return [DatastoreConfig] datastore config.
-      attr_accessor :datastores
+    def agent
+      config['agent']
+    end
 
-      # @!attribute clusters
-      #   @return [Hash<String, ClusterConfig>] child clusters.
-      attr_accessor :clusters
+    def vcenter_host
+      vcenter['host']
+    end
 
-      # Creates a new Datacenter Config model from parsed YAML.
-      #
-      # @param [Hash] config parsed YAML.
-      def initialize(config)
-        @name = config["name"]
+    def vcenter_user
+      vcenter['user']
+    end
 
-        @folders = FolderConfig.new
-        @folders.template = config["template_folder"]
-        @folders.vm = config["vm_folder"]
-        @folders.shared = !!config["use_sub_folder"]
+    def vcenter_password
+      vcenter['password']
+    end
 
-        @datastores = DatastoreConfig.new
-        @datastores.ephemeral_pattern = Regexp.new(config["datastore_pattern"])
-        @datastores.persistent_pattern = Regexp.new(
-            config["persistent_datastore_pattern"])
-        @datastores.disk_path = config["disk_path"]
-        @datastores.allow_mixed = !!config["allow_mixed_datastores"]
+    def datacenter_name
+      vcenter_datacenter['name']
+    end
 
-        @clusters = {}
-        config["clusters"].each do |cluster|
-          cluster_config = ClusterConfig.new(cluster)
-          @clusters[cluster_config.name] = cluster_config
-        end
+    def datacenter_vm_folder
+      vcenter_datacenter['vm_folder']
+    end
 
-        if @clusters.any? { |_, cluster| cluster.resource_pool }
-          @folders.shared = true
-        end
-      end
+    def datacenter_template_folder
+      vcenter_datacenter['template_folder']
     end
 
-    # Cluster config.
-    class ClusterConfig
+    def datacenter_disk_path
+      vcenter_datacenter['disk_path']
+    end
 
-      # @!attribute name
-      #   @return [String] cluster name.
-      attr_accessor :name
+    def datacenter_datastore_pattern
+      Regexp.new(vcenter_datacenter['datastore_pattern'])
+    end
 
-      # @!attribute resource_pool
-      #   @return [String?] optional resource pool to use instead of root.
-      attr_accessor :resource_pool
+    def datacenter_persistent_datastore_pattern
+      Regexp.new(vcenter_datacenter['persistent_datastore_pattern'])
+    end
 
-      # Creates a new Cluster Config model from parsed YAML.
-      #
-      # @param [Hash] config parsed YAML.
-      def initialize(config)
-        case config
-          when String
-            @name = config
-          else
-            @name = config.keys.first
-            @resource_pool = config[@name]["resource_pool"]
-        end
-      end
+    def datacenter_clusters
+      @cluster_objs ||= cluster_objs
     end
 
-    class << self
+    def datacenter_allow_mixed_datastores
+      !!vcenter_datacenter['allow_mixed_datastores']
+    end
 
-      CONFIG_OPTIONS = [
-          :logger,
-          :client,
-          :rest_client,
-          :agent,
-          :copy_disks,
-          :vcenter,
-          :mem_overcommit,
-      ]
+    def datacenter_use_sub_folder
+      datacenter_clusters.any? { |_, cluster| cluster.resource_pool } ||
+        !!vcenter_datacenter['use_sub_folder']
+    end
 
-      CONFIG_OPTIONS.each do |option|
-        attr_accessor option
-      end
+    private
 
-      # Clear all of the properties.
-      #
-      # Used by unit tests.
-      # @return [void]
-      def clear
-        CONFIG_OPTIONS.each do |option|
-          self.instance_variable_set("@#{option}".to_sym, nil)
-        end
-      end
+    attr_reader :config
 
-      # Setup the Config context based on the parsed YAML.
-      #
-      # @return [void]
-      def configure(config)
-        @logger = Bosh::Clouds::Config.logger
-        @schema.validate(config)
-        @agent = config["agent"]
+    def is_validated?
+      raise 'Configuration has not been validated' unless @is_validated
+    end
 
-        unless config["vcenters"].size == 1
-          raise "vSphere CPI only supports a single vCenter."
-        end
-        @vcenter = VCenterConfig.new(config["vcenters"].first)
+    def vcenter
+      config['vcenters'].first
+    end
 
-        @client = Client.new("https://#{@vcenter.host}/sdk/vimService", {
-            "soap_log" => config["soap_log"] || config["cpi_log"]
-        })
-        @client.login(@vcenter.user, @vcenter.password, "en")
+    def vcenter_datacenter
+      vcenter['datacenters'].first
+    end
 
-        @rest_client = HTTPClient.new
-        @rest_client.send_timeout = 14400 # 4 hours, for stemcell uploads
-        @rest_client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    def validate_schema
+      # Membrane schema for the provided config.
+      schema = Membrane::SchemaParser.parse do
+        {
+          'agent' => dict(String, Object), # passthrough to the agent
+          optional('cpi_log') => String,
+          optional('soap_log') => String,
+          optional('mem_overcommit_ratio') => Numeric,
+          optional('copy_disks') => bool,
+          'vcenters' => [{
+                           'host' => String,
+                           'user' => String,
+                           'password' => String,
+                           'datacenters' => [{
+                                               'name' => String,
+                                               'vm_folder' => String,
+                                               'template_folder' => String,
+                                               optional('use_sub_folder') => bool,
+                                               'disk_path' => String,
+                                               'datastore_pattern' => String,
+                                               'persistent_datastore_pattern' => String,
+                                               optional('allow_mixed_datastores') => bool,
+                                               'clusters' => [enum(String,
+                                                                   dict(String, { 'resource_pool' => String }))]
+                                             }]
+                         }]
+        }
+      end
 
-        # HACK: read the session from the SOAP client so we don't leak sessions
-        # when using the REST client
-        cookie_str = @client.stub.cookie
-        @rest_client.cookie_manager.parse(
-            cookie_str, URI.parse("https://#{@vcenter.host}"))
+      schema.validate(config)
+    end
 
-        if config["mem_overcommit_ratio"]
-          @mem_overcommit = config["mem_overcommit_ratio"].to_f
+    def cluster_objs
+      cluster_objs = {}
+      vcenter_datacenter['clusters'].each do |cluster|
+        if cluster.is_a?(Hash)
+          name = cluster.keys.first
+          cluster_objs[name] = ClusterConfig.new(name, cluster[name])
         else
-          @mem_overcommit = 1.0
+          cluster_objs[cluster] = ClusterConfig.new(cluster, {})
         end
-
-        @copy_disks = !!config["copy_disks"]
       end
+      cluster_objs
     end
   end
+
 end