bosh_vsphere_cpi 0.4.9 → 0.5.0

data/lib/cloud/vsphere/client.rb

@@ -13,8 +13,9 @@ module VSphereCloud
 
     def initialize(host, options = {})
       http_client = HTTPClient.new
-      if options["soap_log"]
-        log_file = File.open(options["soap_log"], "w")
+      log_path = options["soap_log"]
+      if log_path
+        log_file = File.open(log_path, "w")
         log_file.sync = true
         http_client.debug_dev = log_file
       end

data/lib/cloud/vsphere/cloud.rb

@@ -1,7 +1,18 @@
+require "rubygems"
+require "membrane"
 require "ruby_vim_sdk"
+
 require "cloud/vsphere/client"
+require "cloud/vsphere/config"
 require "cloud/vsphere/lease_updater"
 require "cloud/vsphere/resources"
+require "cloud/vsphere/resources/cluster"
+require "cloud/vsphere/resources/datacenter"
+require "cloud/vsphere/resources/datastore"
+require "cloud/vsphere/resources/folder"
+require "cloud/vsphere/resources/resource_pool"
+require "cloud/vsphere/resources/scorer"
+require "cloud/vsphere/resources/util"
 require "cloud/vsphere/models/disk"
 
 module VSphereCloud
@@ -14,37 +25,17 @@ module VSphereCloud
     attr_accessor :client
 
     def initialize(options)
-      @vcenters = options["vcenters"]
-      raise "Invalid number of VCenters" unless @vcenters.size == 1
-      @vcenter = @vcenters[0]
-
-      @logger = Bosh::Clouds::Config.logger
-
-      @agent_properties = options["agent"]
-
-      @client = Client.new("https://#{@vcenter["host"]}/sdk/vimService", options)
-      @client.login(@vcenter["user"], @vcenter["password"], "en")
-
-      @rest_client = HTTPClient.new
-      @rest_client.send_timeout = 14400 # 4 hours
-      @rest_client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-      # 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"]}"))
-
-      mem_ratio = 1.0
-      if options["mem_overcommit_ratio"]
-        mem_ratio = options["mem_overcommit_ratio"].to_f
-      end
-
-      @resources = Resources.new(@client, @vcenter, mem_ratio)
+      Config.configure(options)
 
-      # HACK: provide a way to copy the disks instead of moving them.
-      # Used for extra data protection until we have proper backups
-      @copy_disks = options["copy_disks"] || false
+      @logger = Config.logger
+      @client = Config.client
+      @rest_client = Config.rest_client
+      @resources = Resources.new
 
+      # Global lock
       @lock = Mutex.new
+
+      # Resource locks
       @locks = {}
       @locks_mutex = Mutex.new
 
@@ -76,12 +67,13 @@ module VSphereCloud
           @logger.info("Generated name: #{name}")
 
           # TODO: make stemcell friendly version of the calls below
-          cluster, datastore = @resources.get_resources
+          stemcell_size = File.size(image) / (1024 * 1024)
+          cluster, datastore = @resources.place(0, stemcell_size, [])
           @logger.info("Deploying to: #{cluster.mob} / #{datastore.mob}")
 
-          import_spec_result = import_ovf(name, ovf_file, cluster.resource_pool, datastore.mob)
-          lease = obtain_nfc_lease(cluster.resource_pool, import_spec_result.import_spec,
-                                   cluster.datacenter.template_folder)
+          import_spec_result = import_ovf(name, ovf_file, cluster.resource_pool.mob, datastore.mob)
+          lease = obtain_nfc_lease(cluster.resource_pool.mob, import_spec_result.import_spec,
+                                   cluster.datacenter.template_folder.mob)
           @logger.info("Waiting for NFC lease")
           state = wait_for_nfc_lease(lease)
           raise "Could not acquire HTTP NFC lease" unless state == Vim::HttpNfcLease::State::READY
@@ -115,7 +107,7 @@ module VSphereCloud
         Bosh::ThreadPool.new(:max_threads => 32, :logger => @logger).wrap do |pool|
           @resources.datacenters.each_value do |datacenter|
             @logger.info("Looking for stemcell replicas in: #{datacenter.name}")
-            templates = client.get_property(datacenter.template_folder, Vim::Folder, "childEntity", :ensure_all => true)
+            templates = client.get_property(datacenter.template_folder.mob, Vim::Folder, "childEntity", :ensure_all => true)
             template_properties = client.get_properties(templates, Vim::VirtualMachine, ["name"])
             template_properties.each_value do |properties|
               template_name = properties["name"].gsub("%2f", "/")
@@ -133,29 +125,53 @@ module VSphereCloud
       end
     end
 
-    def disk_spec(vm_disk, persistent_disks)
+    def disk_spec(persistent_disks)
       disks = []
-      disks << {"size" => vm_disk, "persistent" => false}
-
-      persistent_disks ||= {}
-      persistent_disks.each do |disk_id|
-        disk = Models::Disk[disk_id]
-        disks << {"size" => disk.size, "persistent" => true, "datacenter" => disk.datacenter, "datastore" => disk.datastore}
+      if persistent_disks
+        persistent_disks.each do |disk_id|
+          disk = Models::Disk[disk_id]
+          disks << {
+              :size => disk.size,
+              :dc_name => disk.datacenter,
+              :ds_name => disk.datastore
+          }
+        end
       end
       disks
     end
 
+    def stemcell_vm(name)
+      dc = @resources.datacenters.values.first
+      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)
       with_thread_name("create_vm(#{agent_id}, ...)") do
         memory = resource_pool["ram"]
         disk = resource_pool["disk"]
         cpu = resource_pool["cpu"]
 
-        disks = disk_spec(disk, disk_locality)
-        cluster, datastore = @resources.get_resources(memory, disks)
+        # 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}")
+        @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,
@@ -194,7 +210,7 @@ module VSphereCloud
 
         @logger.info("Cloning vm: #{replicated_stemcell_vm} to #{name}")
 
-        task = clone_vm(replicated_stemcell_vm, name, cluster.datacenter.vm_folder, cluster.resource_pool,
+        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)
@@ -421,7 +437,8 @@ module VSphereCloud
 
     def find_persistent_datastore(datacenter_name, host_info, disk_size)
       # Find datastore
-      datastore = @resources.find_persistent_datastore(datacenter_name, host_info["cluster"], disk_size)
+      datastore = @resources.place_persistent_datastore(
+          datacenter_name, host_info["cluster"], disk_size)
 
       if datastore.nil?
         raise Bosh::Clouds::NoDiskSpace.new(true), "Not enough persistent space on cluster #{host_info["cluster"]}, #{disk_size}"
@@ -447,21 +464,18 @@ module VSphereCloud
 
         vm_properties = client.get_properties(vm, Vim::VirtualMachine, "config.hardware.device", :ensure_all => true)
         host_info = get_vm_host_info(vm)
-        persistent_datastore = nil
 
         create_disk = false
         if disk.path
           if disk.datacenter == datacenter_name &&
                   @resources.validate_persistent_datastore(datacenter_name, disk.datastore) &&
                   host_info["datastores"].include?(disk.datastore)
-            # Looks like we have a valid persistent data store
-
             @logger.info("Disk already in the right datastore #{datacenter_name} #{disk.datastore}")
-            persistent_datastore = @resources.get_persistent_datastore(datacenter_name, host_info["cluster"],
-                                                                       disk.datastore)
+            persistent_datastore = @resources.persistent_datastore(
+                datacenter_name, host_info["cluster"], disk.datastore)
+            @logger.debug("Datastore: #{persistent_datastore}")
           else
             @logger.info("Disk needs to move from #{datacenter_name} #{disk.datastore}")
-
             # Find the destination datastore
             persistent_datastore = find_persistent_datastore(datacenter_name, host_info, disk.size)
 
@@ -473,7 +487,7 @@ module VSphereCloud
             destination_path = "[#{persistent_datastore.name}] #{datacenter_disk_path}/#{disk.id}"
             @logger.info("Moving #{disk.datacenter}/#{source_path} to #{datacenter_name}/#{destination_path}")
 
-            if @copy_disks
+            if Config.copy_disks
               client.copy_disk(source_datacenter, source_path, datacenter, destination_path)
               @logger.info("Copied disk successfully")
             else
@@ -576,7 +590,7 @@ module VSphereCloud
         disk = Models::Disk.new
         disk.size = size
         disk.save
-        @logger.info("Created disk: #{disk.pretty_inspect}")
+        @logger.info("Created disk: #{disk.inspect}")
         disk.id.to_s
       end
     end
@@ -605,23 +619,27 @@ module VSphereCloud
     end
 
     def get_vm_by_cid(vm_cid)
-      # TODO: fix when we go to multiple DCs
-      datacenter = @resources.datacenters.values.first
-      vm = client.find_by_inventory_path([datacenter.name, "vm", datacenter.vm_folder_name, vm_cid])
-      raise Bosh::Clouds::VMNotFound, "VM `#{vm_cid}' not found" if vm.nil?
-      vm
+      @resources.datacenters.each_value do |datacenter|
+        vm = client.find_by_inventory_path(
+            [datacenter.name, "vm", datacenter.vm_folder.name, vm_cid])
+        unless vm.nil?
+          return vm
+        end
+      end
+      raise Bosh::Clouds::VMNotFound, "VM `#{vm_cid}' not found"
     end
 
     def replicate_stemcell(cluster, datastore, stemcell)
+      # TODO: support more than a single datacenter
       stemcell_vm = client.find_by_inventory_path([cluster.datacenter.name, "vm",
-                                                   cluster.datacenter.template_folder_name, stemcell])
+                                                   cluster.datacenter.template_folder.name, stemcell])
       raise "Could not find stemcell: #{stemcell}" if stemcell_vm.nil?
       stemcell_datastore = client.get_property(stemcell_vm, Vim::VirtualMachine, "datastore", :ensure_all => true)
 
       if stemcell_datastore != datastore.mob
         @logger.info("Stemcell lives on a different datastore, looking for a local copy of: #{stemcell}.")
         local_stemcell_name    = "#{stemcell} / #{datastore.mob.__mo_id__}"
-        local_stemcell_path    = [cluster.datacenter.name, "vm", cluster.datacenter.template_folder_name,
+        local_stemcell_path    = [cluster.datacenter.name, "vm", cluster.datacenter.template_folder.name,
                                   local_stemcell_name]
         replicated_stemcell_vm = client.find_by_inventory_path(local_stemcell_path)
 
@@ -639,8 +657,8 @@ module VSphereCloud
             replicated_stemcell_vm = client.find_by_inventory_path(local_stemcell_path)
             if replicated_stemcell_vm.nil?
               @logger.info("Replicating #{stemcell} (#{stemcell_vm}) to #{local_stemcell_name}")
-              task = clone_vm(stemcell_vm, local_stemcell_name, cluster.datacenter.template_folder,
-                              cluster.resource_pool, :datastore => datastore.mob)
+              task = clone_vm(stemcell_vm, local_stemcell_name, cluster.datacenter.template_folder.mob,
+                              cluster.resource_pool.mob, :datastore => datastore.mob)
               replicated_stemcell_vm = client.wait_for_task(task)
               @logger.info("Replicated #{stemcell} (#{stemcell_vm}) to " +
                                "#{local_stemcell_name} (#{replicated_stemcell_vm})")
@@ -711,7 +729,7 @@ module VSphereCloud
       env["agent_id"] = agent_id
       env["networks"] = networking_env
       env["disks"] = disk_env
-      env.merge!(@agent_properties)
+      env.merge!(Config.agent)
       env
     end
 
@@ -737,7 +755,7 @@ module VSphereCloud
         end
       end
 
-      {:datacenter => datacenter_name, :datastore =>datastore_name, :vm =>vm_name}
+      {:datacenter => datacenter_name, :datastore => datastore_name, :vm => vm_name}
     end
 
     def get_primary_datastore(devices)
@@ -826,7 +844,7 @@ module VSphereCloud
 
     def fetch_file(datacenter_name, datastore_name, path)
       retry_block do
-        url = "https://#{@vcenter["host"]}/folder/#{path}?dcPath=#{URI.escape(datacenter_name)}" +
+        url = "https://#{Config.vcenter.host}/folder/#{path}?dcPath=#{URI.escape(datacenter_name)}" +
         "&dsName=#{URI.escape(datastore_name)}"
 
         response = @rest_client.get(url)
@@ -843,7 +861,7 @@ module VSphereCloud
 
     def upload_file(datacenter_name, datastore_name, path, contents)
       retry_block do
-        url = "https://#{@vcenter["host"]}/folder/#{path}?dcPath=#{URI.escape(datacenter_name)}" +
+        url = "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})
@@ -1052,34 +1070,5 @@ module VSphereCloud
           sleep(1.0)
         end
     end
-
-    def delete_all_vms
-      Bosh::ThreadPool.new(:max_threads => 32, :logger => @logger).wrap do |pool|
-        index = 0
-
-        @resources.datacenters.each_value do |datacenter|
-          vm_folder_path = [datacenter.name, "vm", datacenter.vm_folder_name]
-          vm_folder = client.find_by_inventory_path(vm_folder_path)
-          vms = client.get_managed_objects(Vim::VirtualMachine, :root => vm_folder)
-          next if vms.empty?
-
-          vm_properties = client.get_properties(vms, Vim::VirtualMachine, ["name"])
-
-          vm_properties.each do |_, properties|
-            pool.process do
-              @lock.synchronize {index += 1}
-              vm = properties["name"]
-              @logger.debug("Deleting #{index}/#{vms.size}: #{vm}")
-              begin
-                delete_vm(vm)
-              rescue Exception => e
-                @logger.info("#{e} - #{e.backtrace.join("\n")}")
-              end
-            end
-          end
-        end
-      end
-    end
-
   end
 end

data/lib/cloud/vsphere/config.rb

@@ -0,0 +1,254 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+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}))]
+              }]
+            }]
+        }
+    end
+
+    # vCenter config.
+    class VCenterConfig
+
+      # @!attribute host
+      #   @return [String] vCenter host.
+      attr_accessor :host
+
+      # @!attribute user
+      #   @return [String] vCenter user.
+      attr_accessor :user
+
+      # @!attribute password
+      #   @return [String] vCenter password.
+      attr_accessor :password
+
+      # @!attribute datacenters
+      #   @return [Hash<String, DatacenterConfig>] child datacenters.
+      attr_accessor :datacenters
+
+      # 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 = {}
+
+        # TODO: current limitation to support a single vDC.
+        # Primarily due to stemcell replication logic calling CloneVM_Task which
+        # does not copy across datacenters. Should use CopyDatastoreFile_Task /
+        # CopyVirtualDisk_Task.
+        unless config["datacenters"].size == 1
+          raise "vSphere CPI only supports a single datacenter."
+        end
+
+        config["datacenters"].each do |dc|
+          dc_config = DatacenterConfig.new(dc)
+          @datacenters[dc_config.name] = dc_config
+        end
+      end
+    end
+
+    # Folder config.
+    class FolderConfig
+      # @!attribute vm
+      #   @return [String] vm folder path.
+      attr_accessor :vm
+
+      # @!attribute template
+      #   @return [String] template/stemcell folder path.
+      attr_accessor :template
+
+      # @!attribute shared
+      #   @return [true, false] boolean indicating shared folders, so an
+      #     additional namespace should be used.
+      attr_accessor :shared
+    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
+
+      # @!attribute disk_path
+      #   @return [String] VMDK datastore path.
+      attr_accessor :disk_path
+
+      # @!attribute allow_mixed
+      #   @return [true, false] boolean indicating whether persistent and
+      #     ephemeral datastores can overlap..
+      attr_accessor :allow_mixed
+    end
+
+    # Datacenter config.
+    class DatacenterConfig
+
+      # @!attribute name
+      #   @return [String] datacenter name.
+      attr_accessor :name
+
+      # @!attribute folders
+      #   @return [FolderConfig] folder config.
+      attr_accessor :folders
+
+      # @!attribute datastores
+      #   @return [DatastoreConfig] datastore config.
+      attr_accessor :datastores
+
+      # @!attribute clusters
+      #   @return [Hash<String, ClusterConfig>] child clusters.
+      attr_accessor :clusters
+
+      # Creates a new Datacenter Config model from parsed YAML.
+      #
+      # @param [Hash] config parsed YAML.
+      def initialize(config)
+        @name = config["name"]
+
+        @folders = FolderConfig.new
+        @folders.template = config["template_folder"]
+        @folders.vm = config["vm_folder"]
+        @folders.shared = !!config["use_sub_folder"]
+
+        @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"]
+
+        @clusters = {}
+        config["clusters"].each do |cluster|
+          cluster_config = ClusterConfig.new(cluster)
+          @clusters[cluster_config.name] = cluster_config
+        end
+
+        if @clusters.any? { |_, cluster| cluster.resource_pool }
+          @folders.shared = true
+        end
+      end
+    end
+
+    # Cluster config.
+    class ClusterConfig
+
+      # @!attribute name
+      #   @return [String] cluster name.
+      attr_accessor :name
+
+      # @!attribute resource_pool
+      #   @return [String?] optional resource pool to use instead of root.
+      attr_accessor :resource_pool
+
+      # 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
+    end
+
+    class << self
+
+      CONFIG_OPTIONS = [
+          :logger,
+          :client,
+          :rest_client,
+          :agent,
+          :copy_disks,
+          :vcenter,
+          :mem_overcommit,
+      ]
+
+      CONFIG_OPTIONS.each do |option|
+        attr_accessor option
+      end
+
+      # 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
+
+      # 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"]
+
+        unless config["vcenters"].size == 1
+          raise "vSphere CPI only supports a single vCenter."
+        end
+        @vcenter = VCenterConfig.new(config["vcenters"].first)
+
+        @client = Client.new("https://#{@vcenter.host}/sdk/vimService", {
+            "soap_log" => config["soap_log"] || config["cpi_log"]
+        })
+        @client.login(@vcenter.user, @vcenter.password, "en")
+
+        @rest_client = HTTPClient.new
+        @rest_client.send_timeout = 14400 # 4 hours, for stemcell uploads
+        @rest_client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        # 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}"))
+
+        if config["mem_overcommit_ratio"]
+          @mem_overcommit = config["mem_overcommit_ratio"].to_f
+        else
+          @mem_overcommit = 1.0
+        end
+
+        @copy_disks = !!config["copy_disks"]
+      end
+    end
+  end
+end