chef-provisioning-vsphere 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e7308c027bc21589567543a1144202d7b8868641
-  data.tar.gz: 0f7ce9c37b7ae5662446ca99feb473c61fbbb6ce
+  metadata.gz: 12dda7faea087859dd1c57ca94de5f57075f34ac
+  data.tar.gz: 8ed3e2836949def6569e148c067f4ee427405218
 SHA512:
-  metadata.gz: f9c2f84cabb77cd7cc0540e3a4c648129d97360d4430d2c6ff9d1dd31f1afeb3429191aae723e82c8b2c5c033af5a6e54c779aebf4de851df138ce68a6ae02ec
-  data.tar.gz: 5fa9251bbca1fe98791fe01d27bdf015118d32f5c1832172d0bdf4af075b5fb6d07ba8a13170773628a540852f32d5026c7b3b1e8e374a3a515ca899a2fc2c1e
+  metadata.gz: 2daa6f17429a7bc45099cf006178fd36da7f4dd684d288b67569f91dccbc2b2562271dfb049c209a237b64fc98efbd7127a4b97b2e5e4a542a020a36ebbaca8b
+  data.tar.gz: a7adc29123fade718ff1e960ac89d57c2a46811c11ce95ac32cf75252f6c4b95879a55fcf9e56920423861c737c765260e3db13846de2e298b2a81a2807a84e8

data/README.md

@@ -76,6 +76,7 @@ This will use chef-zero and needs no chef server (only works for ssh). Note that
 - `[:use_linked_clone]` - (true/false) great for testing but not recommended for production.
 - `[:datacenter]` - Name of vsphere datacenter (*required*)
 - `[:template_name]` - path to vmware template (can be template or a shutown vm) (*required*)
+- `[:template_folder]` - path to a folder containing the template (do not use if template is in the root vm folder)
 - `[:vm_folder]` - path to a folder where the machine will be created.
 - `[:datastore]` - name of datastore to use
 - `[:num_cpus]` -  number of cpus to allocate to machine

data/lib/chef/provisioning/vsphere_driver/clone_spec_builder.rb

@@ -0,0 +1,201 @@
+module ChefProvisioningVsphere
+  class CloneSpecBuilder
+    def initialize(vsphere_helper, action_handler)
+      @vsphere_helper = vsphere_helper
+      @action_handler = action_handler
+    end
+
+    attr_reader :vsphere_helper
+    attr_reader :action_handler
+
+    def build(vm_template, vm_name, options)
+      clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(
+        location: relocate_spec_for(vm_template, options),
+        powerOn: false,
+        template: false,
+        config: RbVmomi::VIM.VirtualMachineConfigSpec(
+          :cpuHotAddEnabled => true,
+          :memoryHotAddEnabled => true,
+          :cpuHotRemoveEnabled => true,
+          :deviceChange => Array.new)
+      )
+
+      unless options[:annotation].to_s.nil?
+        clone_spec.config.annotation = options[:annotation]
+      end
+
+      unless options[:num_cpus].to_s.nil?
+        clone_spec.config.numCPUs = options[:num_cpus]
+      end
+
+      unless options[:memory_mb].to_s.nil?
+        clone_spec.config.memoryMB = options[:memory_mb]
+      end
+
+      unless options[:network_name].nil?
+        deviceAdditions, changes = vsphere_helper.network_device_changes(
+          action_handler,
+          vm_template,
+          options
+        )
+        clone_spec.config.deviceChange = changes
+      end
+
+      clone_spec.customization = customization_options_from(
+        vm_template,
+        vm_name,
+        options
+      )
+
+      clone_spec
+    end
+
+    def relocate_spec_for(vm_template, options)
+      rspec = RbVmomi::VIM.VirtualMachineRelocateSpec
+      host = nil
+
+      if options.has_key?(:host)
+        host = vsphere_helper.find_host(options[:host])
+        rspec.host = host
+      end
+
+      if options[:resource_pool]
+        rspec.pool = vsphere_helper.find_pool(options[:resource_pool])
+      elsif vm_template.config.template && !host.nil?
+        rspec.pool = host.parent.resourcePool # assign to the "invisible" pool root
+      elsif vm_template.config.template
+        raise 'either :host or :resource_pool must be specified when cloning from a VM Template'
+      end
+
+
+      if options[:use_linked_clone]
+        if vm_template.config.template
+          Chef::Log.warn("Using a VM Template, ignoring use_linked_clone.")
+        else
+          vsphere_helper.create_delta_disk(vm_template)
+          rspec.diskMoveType = :moveChildMostDiskBacking
+        end
+      end
+
+      unless options[:datastore].to_s.empty?
+        rspec.datastore = vsphere_helper.find_datastore(options[:datastore])
+      end
+
+      rspec
+    end
+
+    def customization_options_from(vm_template, vm_name, options)
+      if options.has_key?(:customization_spec)
+        if(options[:customization_spec].is_a?(Hash))
+          cust_options = options[:customization_spec]
+          ip_settings = cust_options[:ipsettings]
+          cust_domain = cust_options[:domain]
+
+          raise ArgumentError, 'domain is required' unless cust_domain
+          cust_ip_settings = nil
+          if ip_settings && ip_settings.key?(:ip)
+            unless cust_options[:ipsettings].key?(:subnetMask)
+              raise ArgumentError, 'subnetMask is required for static ip'
+            end
+            cust_ip_settings = RbVmomi::VIM::CustomizationIPSettings.new(
+              ip_settings)
+            action_handler.report_progress "customizing #{vm_name} \
+              with static IP #{ip_settings[:ip]}"
+            cust_ip_settings.ip = RbVmomi::VIM::CustomizationFixedIp(
+              :ipAddress => ip_settings[:ip])
+          end
+          if cust_ip_settings.nil?
+            cust_ip_settings= RbVmomi::VIM::CustomizationIPSettings.new(
+              :ip => RbVmomi::VIM::CustomizationDhcpIpGenerator.new())
+            cust_ip_settings.dnsServerList = ip_settings[:dnsServerList]
+            action_handler.report_progress "customizing #{vm_name} with /
+              dynamic IP and DNS: #{ip_settings[:dnsServerList]}"
+          end
+
+          cust_ip_settings.dnsDomain = cust_domain
+          global_ip_settings = RbVmomi::VIM::CustomizationGlobalIPSettings.new
+          global_ip_settings.dnsServerList = cust_ip_settings.dnsServerList
+          global_ip_settings.dnsSuffixList = [cust_domain]
+          cust_hostname = hostname_from(cust_options, vm_name)
+          cust_hwclockutc = cust_options[:hw_clock_utc]
+          cust_timezone = cust_options[:time_zone]
+
+          if vm_template.config.guestId.start_with?('win')
+            cust_prep = windows_prep_for(options, vm_name)
+          else
+            cust_prep = RbVmomi::VIM::CustomizationLinuxPrep.new(
+              :domain => cust_domain,
+              :hostName => cust_hostname,
+              :hwClockUTC => cust_hwclockutc,
+              :timeZone => cust_timezone
+            )
+          end
+          cust_adapter_mapping = [
+            RbVmomi::VIM::CustomizationAdapterMapping.new(
+              :adapter => cust_ip_settings)
+          ]
+          RbVmomi::VIM::CustomizationSpec.new(
+            :identity => cust_prep,
+            :globalIPSettings => global_ip_settings,
+            :nicSettingMap => cust_adapter_mapping
+          )
+        else
+          vsphere_helper.find_customization_spec(cust_options)
+        end
+      end
+    end
+
+    def hostname_from(options, vm_name)
+      hostname = options[:hostname] || vm_name
+      test = /^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])$/
+      if !(hostname =~ test)
+        raise 'Only letters, numbers or hyphens in hostnames allowed'
+      end
+      RbVmomi::VIM::CustomizationFixedName.new(:name => hostname)
+    end
+
+    def windows_prep_for(options, vm_name)
+      cust_options = options[:customization_spec]
+      cust_runonce = RbVmomi::VIM::CustomizationGuiRunOnce.new(
+        :commandList => [
+          'winrm set winrm/config/client/auth @{Basic="true"}',
+          'winrm set winrm/config/service/auth @{Basic="true"}',
+          'winrm set winrm/config/service @{AllowUnencrypted="true"}',
+          'shutdown -l'])
+
+      cust_login_password = RbVmomi::VIM::CustomizationPassword(
+        :plainText => true,
+        :value => options[:ssh][:password])
+      if cust_options.has_key?(:domain) and cust_options[:domain] != 'local'
+        cust_domain_password = RbVmomi::VIM::CustomizationPassword(
+          :plainText => true,
+          :value => ENV['domainAdminPassword'] || cust_options[:domainAdminPassword])
+        cust_id = RbVmomi::VIM::CustomizationIdentification.new(
+          :joinDomain => cust_options[:domain],
+          :domainAdmin => cust_options[:domainAdmin],
+          :domainAdminPassword => cust_domain_password)
+        #puts "my env passwd is: #{ENV['domainAdminPassword']}"
+        action_handler.report_progress "joining domain #{cust_options[:domain]} /
+          with user: #{cust_options[:domainAdmin]}"
+      else
+        cust_id = RbVmomi::VIM::CustomizationIdentification.new(
+          :joinWorkgroup => 'WORKGROUP')
+      end
+      cust_gui_unattended = RbVmomi::VIM::CustomizationGuiUnattended.new(
+        :autoLogon => true,
+        :autoLogonCount => 1,
+        :password => cust_login_password,
+        :timeZone => cust_options[:win_time_zone])
+      cust_userdata = RbVmomi::VIM::CustomizationUserData.new(
+        :computerName => hostname_from(cust_options, vm_name),
+        :fullName => cust_options[:org_name],
+        :orgName => cust_options[:org_name],
+        :productId => cust_options[:product_id])
+      RbVmomi::VIM::CustomizationSysprep.new(
+        :guiRunOnce => cust_runonce,
+        :identification => cust_id,
+        :guiUnattended => cust_gui_unattended,
+        :userData => cust_userdata)
+    end
+  end
+end

data/lib/chef/provisioning/vsphere_driver/driver.rb

@@ -3,6 +3,7 @@ require 'cheffish/merged_config'
 require 'chef/provisioning/driver'
 require 'chef/provisioning/machine/windows_machine'
 require 'chef/provisioning/machine/unix_machine'
+require 'chef/provisioning/vsphere_driver/clone_spec_builder'
 require 'chef/provisioning/vsphere_driver/version'
 require 'chef/provisioning/vsphere_driver/vsphere_helpers'
 require 'chef/provisioning/vsphere_driver/vsphere_url'
@@ -11,7 +12,6 @@ module ChefProvisioningVsphere
   # Provisions machines in vSphere.
   class VsphereDriver < Chef::Provisioning::Driver
     include Chef::Mixin::ShellOut
-    include ChefProvisioningVsphere::Helpers
 
     def self.from_url(driver_url, config)
       VsphereDriver.new(driver_url, config)
@@ -163,7 +163,7 @@ module ChefProvisioningVsphere
     end
 
     def find_or_create_vm(bootstrap_options, machine_spec, action_handler)
-      vm = find_vm(
+      vm = vsphere_helper.find_vm(
         bootstrap_options[:vm_folder],
         machine_spec.name
       )
@@ -231,7 +231,7 @@ module ChefProvisioningVsphere
       end
       return if networks.nil? || networks.count < 2
 
-      new_nics = add_extra_nic(
+      new_nics = vsphere_helper.add_extra_nic(
         action_handler,
         vm_template_for(bootstrap_options),
         bootstrap_options,
@@ -313,7 +313,7 @@ module ChefProvisioningVsphere
           msg << vm.guest.toolsRunningStatus
           msg << '. powering up server...'
           action_handler.report_progress(msg.join)
-          start_vm(vm)
+          vsphere_helper.start_vm(vm)
         else
           restart_server(action_handler, machine_spec, machine_options)
         end
@@ -395,7 +395,7 @@ module ChefProvisioningVsphere
       vm = vm_for(machine_spec)
       if vm
         action_handler.perform_action "Shutdown guest OS and power off VM [#{vm.parent.name}/#{vm.name}]" do
-          stop_vm(vm)
+          vsphere_helper.stop_vm(vm)
         end
       end
     end
@@ -405,7 +405,7 @@ module ChefProvisioningVsphere
       vm = vm_for(machine_spec)
       if vm
         action_handler.perform_action "Power on VM [#{vm.parent.name}/#{vm.name}]" do
-          start_vm(vm, machine_options[:bootstrap_options][:ssh][:port])
+          vsphere_helper.start_vm(vm, machine_options[:bootstrap_options][:ssh][:port])
         end
       end
       vm
@@ -484,25 +484,53 @@ module ChefProvisioningVsphere
 
     def vm_for(machine_spec)
       if machine_spec.location
-        find_vm_by_id(machine_spec.location['server_id'])
+        vsphere_helper.find_vm_by_id(machine_spec.location['server_id'])
       else
         nil
       end
     end
 
     def clone_vm(action_handler, bootstrap_options, machine_name)
-      do_vm_clone(
-        action_handler,
-        vm_template_for(bootstrap_options),
-        machine_name,
-        bootstrap_options
+      vm_template = vm_template_for(bootstrap_options)
+
+      spec_builder = CloneSpecBuilder.new(vsphere_helper, action_handler)
+      clone_spec = spec_builder.build(vm_template, machine_name, bootstrap_options)
+      Chef::Log.debug("Clone spec: #{clone_spec.pretty_inspect}")
+
+      vm_folder = vsphere_helper.find_folder(bootstrap_options[:vm_folder])
+      vm_template.CloneVM_Task(
+        name: machine_name,
+        folder: vm_folder,
+        spec: clone_spec
+      ).wait_for_completion
+
+      vm = vsphere_helper.find_vm(vm_folder, machine_name)
+
+      if bootstrap_options[:additional_disk_size_gb].to_i > 0
+        task = vm.ReconfigVM_Task(
+          spec: RbVmomi::VIM.VirtualMachineConfigSpec(
+            deviceChange: [
+              vsphere_helper.virtual_disk_for(vm, bootstrap_options)
+            ]
+          )
+        )
+        task.wait_for_completion
+      end
+
+      vm
+    end
+
+    def vsphere_helper
+      @vsphere_helper ||= VsphereHelper.new(
+        connect_options, 
+        config[:machine_options][:bootstrap_options][:datacenter]
       )
     end
 
     def vm_template_for(bootstrap_options)
       template_folder = bootstrap_options[:template_folder]
       template_name   = bootstrap_options[:template_name]
-      find_vm(template_folder, template_name) ||
+      vsphere_helper.find_vm(template_folder, template_name) ||
         raise("vSphere VM Template not found [#{template_folder}/#{template_name}]")
     end
 

data/lib/chef/provisioning/vsphere_driver/version.rb

@@ -1,3 +1,3 @@
 module ChefProvisioningVsphere
-  VERSION = '0.5.7'
+  VERSION = '0.5.8'
 end

data/lib/chef/provisioning/vsphere_driver/vsphere_helpers.rb

@@ -1,16 +1,24 @@
 require 'rbvmomi'
 
 module ChefProvisioningVsphere
-  module Helpers
+  class VsphereHelper
 
     if !$guest_op_managers
       $guest_op_managers = {}
     end
 
-    def vim(options = connect_options)
+    def initialize(connect_options, datacenter_name)
+      @connect_options = connect_options
+      @datacenter_name = datacenter_name
+    end
+
+    attr_reader :connect_options
+    attr_reader :datacenter_name
+
+    def vim
       if @current_connection.nil? or @current_connection.serviceContent.sessionManager.currentSession.nil?
-        puts "establishing connection to #{options[:host]}"
-        @current_connection = RbVmomi::VIM.connect options
+        puts "establishing connection to #{connect_options[:host]}"
+        @current_connection = RbVmomi::VIM.connect connect_options
         str_conn = @current_connection.pretty_inspect # a string in the format of VIM(host ip)
         
         # we are caching guest operation managers in a global variable...terrible i know
@@ -31,22 +39,14 @@ module ChefProvisioningVsphere
       folder.find(vm_name, RbVmomi::VIM::VirtualMachine)
     end
 
-    def find_vm_by_id(uuid, connection = vim)
-      vm = connection.searchIndex.FindByUuid(
+    def find_vm_by_id(uuid)
+      vm = vim.searchIndex.FindByUuid(
         uuid: uuid,
         vmSearch: true,
         instanceUuid: true
       )
     end
 
-    def vm_started?(vm, wait_on_port = 22)
-      return false if vm.nil?
-      state = vm.runtime.powerState
-      return false unless state == 'poweredOn'
-      return false unless port_ready?(vm, wait_on_port)
-      return true
-    end
-
     def vm_stopped?(vm)
       return true if vm.nil?
       state = vm.runtime.powerState
@@ -70,31 +70,6 @@ module ChefProvisioningVsphere
       end
     end
 
-    def port_ready?(vm, port)
-      vm_ip = vm.guest.ipAddress
-      return false if vm_ip.nil?
-
-      begin
-        tcp_socket = TCPSocket.new(vm_ip, port)
-        readable = IO.select([tcp_socket], nil, nil, 5)
-        if readable
-          true
-        else
-          false
-        end
-      rescue Errno::ETIMEDOUT
-        false
-      rescue Errno::EPERM
-        false
-      rescue Errno::ECONNREFUSED
-        false
-      rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH
-        false
-      ensure
-        tcp_socket && tcp_socket.close
-      end
-    end
-
     #folder could be like:  /Level1/Level2/folder_name
     def find_folder(folder_name)
       base = datacenter.vmFolder
@@ -108,9 +83,8 @@ module ChefProvisioningVsphere
     end
 
     def datacenter
-      dc_name = config[:machine_options][:bootstrap_options][:datacenter]
-      @datacenter ||= vim.serviceInstance.find_datacenter(dc_name) ||
-        raise("vSphere Datacenter not found [#{dc_name}]")
+      @datacenter ||= vim.serviceInstance.find_datacenter(datacenter_name) ||
+        raise("vSphere Datacenter not found [#{datacenter_name}]")
     end
 
     def network_adapter_for(operation, network_name, network_label, device_key, backing_info)
@@ -132,56 +106,6 @@ module ChefProvisioningVsphere
       vm.config.hardware.device.select {|d| d.is_a?(RbVmomi::VIM::VirtualEthernetCard)}
     end
 
-    def do_vm_clone(action_handler, vm_template, vm_name, options)
-      deviceAdditions = []
-
-      clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(
-        location: relocate_spec_for(vm_template, options),
-        powerOn: false,
-        template: false,
-        config: RbVmomi::VIM.VirtualMachineConfigSpec(
-          :cpuHotAddEnabled => true,
-          :memoryHotAddEnabled => true,
-          :cpuHotRemoveEnabled => true,
-          :deviceChange => Array.new)
-      )
-
-      clone_spec.customization = customization_options_from(action_handler, vm_template, vm_name, options)
-
-      unless options[:annotation].to_s.nil?
-        clone_spec.config.annotation = options[:annotation]
-      end
-
-      unless options[:num_cpus].to_s.nil?
-        clone_spec.config.numCPUs = options[:num_cpus]
-      end
-
-      unless options[:memory_mb].to_s.nil?
-        clone_spec.config.memoryMB = options[:memory_mb]
-      end
-
-      unless options[:network_name].nil?
-        deviceAdditions, changes = network_device_changes(action_handler, vm_template, options)
-        clone_spec.config.deviceChange = changes
-      end
-
-      vm_folder = find_folder(options[:vm_folder])
-      vm_template.CloneVM_Task(
-        name: vm_name,
-        folder: vm_folder,
-        spec: clone_spec
-      ).wait_for_completion
-
-      vm = find_vm(vm_folder, vm_name)
-
-      if options[:additional_disk_size_gb].to_i > 0
-        task = vm.ReconfigVM_Task(:spec => RbVmomi::VIM.VirtualMachineConfigSpec(:deviceChange => [virtual_disk_for(vm, options)]))
-        task.wait_for_completion
-      end
-
-      vm
-    end
-
     def add_extra_nic(action_handler, vm_template, options, vm)
       deviceAdditions, changes = network_device_changes(action_handler, vm_template, options)
 
@@ -206,28 +130,6 @@ module ChefProvisioningVsphere
       end
     end
 
-    def relocate_spec_for(vm_template, options)
-      if options.has_key?(:host)
-        host = find_host(options[:host])
-        rspec = RbVmomi::VIM.VirtualMachineRelocateSpec(host: host) 
-      else
-        pool = options[:resource_pool] ? find_pool(options[:resource_pool]) : vm_template.resourcePool
-        rspec = RbVmomi::VIM.VirtualMachineRelocateSpec(pool: pool)
-        raise 'either :host or :resource_pool must be specified when cloning from a VM Template' if pool.nil?
-      end
-
-      if options.has_key?(:use_linked_clone)
-        create_delta_disk(vm_template)
-        rspec.diskMoveType = :moveChildMostDiskBacking
-      end
-
-      unless options[:datastore].to_s.empty?
-        rspec.datastore = find_datastore(options[:datastore])
-      end
-
-      rspec
-    end
-
     def create_delta_disk(vm_template)
       disks = vm_template.config.hardware.device.grep(RbVmomi::VIM::VirtualDisk)
       disks.select { |disk| disk.backing.parent == nil }.each do |disk|
@@ -326,114 +228,12 @@ module ChefProvisioningVsphere
       datacenter.datastore.find { |f| f.info.name == datastore_name } or raise "no such datastore #{datastore_name}"
     end
 
-    def customization_options_from(action_handler, vm_template, vm_name, options)
-      if options.has_key?(:customization_spec)
-        if(options[:customization_spec].is_a?(Hash))
-          cust_options = options[:customization_spec]
-          ip_settings = cust_options[:ipsettings]
-          cust_domain = cust_options[:domain]
-
-          raise ArgumentError, 'domain is required' unless cust_domain
-          cust_ip_settings = nil
-          if ip_settings && ip_settings.key?(:ip)
-            unless cust_options[:ipsettings].key?(:subnetMask)
-              raise ArgumentError, 'subnetMask is required for static ip'
-            end
-            cust_ip_settings = RbVmomi::VIM::CustomizationIPSettings.new(ip_settings)
-            action_handler.report_progress "customizing #{vm_name} with static IP #{ip_settings[:ip]}"
-            cust_ip_settings.ip = RbVmomi::VIM::CustomizationFixedIp(:ipAddress => ip_settings[:ip])
-          end
-          if cust_ip_settings.nil?
-            cust_ip_settings= RbVmomi::VIM::CustomizationIPSettings.new(:ip => RbVmomi::VIM::CustomizationDhcpIpGenerator.new())
-            cust_ip_settings.dnsServerList = ip_settings[:dnsServerList]
-            action_handler.report_progress "customizing #{vm_name} with dynamic IP and DNS: #{ip_settings[:dnsServerList]}"
-          end
-
-          cust_ip_settings.dnsDomain = cust_domain
-          cust_global_ip_settings = RbVmomi::VIM::CustomizationGlobalIPSettings.new
-          cust_global_ip_settings.dnsServerList = cust_ip_settings.dnsServerList
-          cust_global_ip_settings.dnsSuffixList = [cust_domain]
-          cust_hostname = hostname_from(cust_options, vm_name)
-          cust_hwclockutc = cust_options[:hw_clock_utc]
-          cust_timezone = cust_options[:time_zone]
-
-          if vm_template.config.guestId.start_with?('win')
-            cust_prep = windows_prep_for(action_handler, options, vm_name)
-          else
-            cust_prep = RbVmomi::VIM::CustomizationLinuxPrep.new(
-              :domain => cust_domain,
-              :hostName => cust_hostname,
-              :hwClockUTC => cust_hwclockutc,
-              :timeZone => cust_timezone
-            )
-          end
-          cust_adapter_mapping = [RbVmomi::VIM::CustomizationAdapterMapping.new(:adapter => cust_ip_settings)]
-          RbVmomi::VIM::CustomizationSpec.new(
-            :identity => cust_prep,
-            :globalIPSettings => cust_global_ip_settings,
-            :nicSettingMap => cust_adapter_mapping
-          )
-        else
-          find_customization_spec(cust_options)
-        end
-      end
-    end
-
-    def windows_prep_for(action_handler, options, vm_name)
-      cust_options = options[:customization_spec]
-      cust_runonce = RbVmomi::VIM::CustomizationGuiRunOnce.new(
-        :commandList => [
-          'winrm set winrm/config/client/auth @{Basic="true"}',
-          'winrm set winrm/config/service/auth @{Basic="true"}',
-          'winrm set winrm/config/service @{AllowUnencrypted="true"}',
-          'shutdown -l'])
-
-      cust_login_password = RbVmomi::VIM::CustomizationPassword(
-        :plainText => true,
-        :value => options[:ssh][:password])
-      if cust_options.has_key?(:domain) and cust_options[:domain] != 'local'
-        cust_domain_password = RbVmomi::VIM::CustomizationPassword(
-          :plainText => true,
-          :value => ENV['domainAdminPassword'] || cust_options[:domainAdminPassword])
-        cust_id = RbVmomi::VIM::CustomizationIdentification.new(
-          :joinDomain => cust_options[:domain],
-          :domainAdmin => cust_options[:domainAdmin],
-          :domainAdminPassword => cust_domain_password)
-        #puts "my env passwd is: #{ENV['domainAdminPassword']}"
-        action_handler.report_progress "joining domain #{cust_options[:domain]} with user: #{cust_options[:domainAdmin]}"
-      else
-        cust_id = RbVmomi::VIM::CustomizationIdentification.new(
-          :joinWorkgroup => 'WORKGROUP')
-      end
-      cust_gui_unattended = RbVmomi::VIM::CustomizationGuiUnattended.new(
-        :autoLogon => true,
-        :autoLogonCount => 1,
-        :password => cust_login_password,
-        :timeZone => cust_options[:win_time_zone])
-      cust_userdata = RbVmomi::VIM::CustomizationUserData.new(
-        :computerName => hostname_from(cust_options, vm_name),
-        :fullName => cust_options[:org_name],
-        :orgName => cust_options[:org_name],
-        :productId => cust_options[:product_id])
-      RbVmomi::VIM::CustomizationSysprep.new(
-        :guiRunOnce => cust_runonce,
-        :identification => cust_id,
-        :guiUnattended => cust_gui_unattended,
-        :userData => cust_userdata)
-    end
-
-    def hostname_from(options, vm_name)
-      if options.key?(:hostname)
-        RbVmomi::VIM::CustomizationFixedName.new(:name => options[:hostname])
-      else
-        RbVmomi::VIM::CustomizationFixedName.new(:name => vm_name)
-      end
-    end
-
     def find_entity(name, parent_folder, &block)
       parts = name.split('/').reject(&:empty?)
       parts.each do |item|
+        Chef::Log.debug("Identifying entity part: #{item} in folder type: #{parent_folder.class}")
         if parent_folder.is_a? RbVmomi::VIM::Folder
+          Chef::Log.debug('Parent folder is a folder')
           parent_folder = parent_folder.childEntity.find { |f| f.name == item }
         else
           parent_folder = block.call(parent_folder, item)
@@ -456,20 +256,28 @@ module ChefProvisioningVsphere
 
       raise "vSphere Host not found [#{host_name}]" if host.nil?
 
-      if !host.is_a?(RbVmomi::VIM::HostSystem) && host.respond_to?(:host)
-        host = host.host
+      if host.is_a?(RbVmomi::VIM::ComputeResource)
+        host = host.host.first
       end
       host
     end
 
     def find_pool(pool_name)
+      Chef::Log.debug("Finding pool: #{pool_name}")
       pool = find_entity(pool_name, datacenter.hostFolder) do |parent, part|
         case parent
-        when RbVmomi::VIM::ClusterComputeResource || RbVmomi::VIM::ComputeResource
+        when RbVmomi::VIM::ClusterComputeResource, RbVmomi::VIM::ComputeResource
+          Chef::Log.debug("finding #{part} in a #{parent.class}: #{parent.name}")
+          Chef::Log.debug("Parent root pool has #{parent.resourcePool.resourcePool.count} pools")
+          parent.resourcePool.resourcePool.each { |p| Chef::Log.debug(p.name ) }
           parent.resourcePool.resourcePool.find { |f| f.name == part }
         when RbVmomi::VIM::ResourcePool
+          Chef::Log.debug("finding #{part} in a Resource Pool: #{parent.name}")
+          Chef::Log.debug("Pool has #{parent.resourcePool.count} pools")
+          parent.resourcePool.each { |p| Chef::Log.debug(p.name ) }
           parent.resourcePool.find { |f| f.name == part }
         else
+          Chef::Log.debug("parent of #{part} is unexpected type: #{parent.class}")
           nil
         end
       end

data/spec/integration_tests/vsphere_driver_spec.rb

@@ -34,12 +34,11 @@ require 'chef/provisioning/machine_spec'
   # }
 
 describe 'vsphere_driver' do
-  include ChefProvisioningVsphere::Helpers
-
   before :all do
     @vm_name = "cmvd-test-#{SecureRandom.hex}"
     @metal_config = eval File.read(File.expand_path('../config.rb', __FILE__))
     Cheffish.honor_local_mode do
+      Chef::Log.level = :debug
       chef_server = Cheffish.default_chef_server
       @machine_spec = Chef::Provisioning.chef_managed_entry_store(chef_server).new_entry(:machine, @vm_name)
       url = URI::VsphereUrl.from_config(@metal_config[:driver_options]).to_s
@@ -49,8 +48,11 @@ describe 'vsphere_driver' do
       @metal_config[:machine_options][:convergence_options] = {:chef_server => chef_server}
       machine = @driver.ready_machine(action_handler, @machine_spec, @metal_config[:machine_options])
       @server_id = @machine_spec.location['server_id']
-      @connection = vim(@metal_config[:driver_options])
-      @vm = find_vm_by_id(@server_id, @connection)
+      @vsphere_helper = ChefProvisioningVsphere::VsphereHelper.new(
+        @metal_config[:driver_options],
+        @metal_config[:machine_options][:bootstrap_options][:datacenter]
+      )
+      @vm = @vsphere_helper.find_vm_by_id(@server_id)
     end
   end
 
@@ -101,7 +103,7 @@ describe 'vsphere_driver' do
       end
     end
     it 'is in the correct datacenter' do
-      expect(@connection.serviceInstance.find_datacenter(@metal_config[:machine_options][:bootstrap_options][:datacenter]).find_vm("#{@vm.parent.name}/#{@vm_name}")).not_to eq(nil)
+      expect(@vsphere_helper.vim.serviceInstance.find_datacenter(@metal_config[:machine_options][:bootstrap_options][:datacenter]).find_vm("#{@vm.parent.name}/#{@vm_name}")).not_to eq(nil)
     end
     it 'has an added disk of the correct size' do
       disk_count = @vm.disks.count
@@ -146,7 +148,7 @@ describe 'vsphere_driver' do
           @metal_config[:machine_options]
         )
       end
-      vm = find_vm_by_id(@server_id, @connection)
+      vm = @vsphere_helper.find_vm_by_id(@server_id)
       expect(vm).to eq(nil)
     end
   end

data/spec/unit_tests/clone_spec_builder_spec.rb

@@ -0,0 +1,161 @@
+require 'chef/provisioning/vsphere_driver'
+require_relative 'support/fake_action_handler'
+require_relative 'support/vsphere_helper_stub'
+
+describe ChefProvisioningVsphere::CloneSpecBuilder do
+  let(:options) { Hash.new }
+  let(:vm_template) { double('template') }
+
+  before do
+    allow(vm_template).to receive_message_chain(:config, :guestId)
+      .and_return('guest')
+    allow(vm_template).to receive_message_chain(:config, :template)
+      .and_return(false)
+  end
+
+  subject do
+    builder = ChefProvisioningVsphere::CloneSpecBuilder.new(
+      ChefProvisioningVsphereStubs::VsphereHelperStub.new,
+      ChefProvisioningVsphereStubs::FakeActionHandler.new
+    )
+    builder.build(vm_template, 'machine_name', options)
+  end
+
+  context 'using linked clones' do
+    before { options[:use_linked_clone] = true }
+
+    it 'sets the disk move type of the relocation spec' do
+      expect(subject.location.diskMoveType).to be :moveChildMostDiskBacking
+    end
+  end
+
+  context 'using linked clone on a template source' do
+    before do
+      options[:use_linked_clone] = true
+      options[:host] = 'host'
+      allow(vm_template).to receive_message_chain(:config, :template)
+        .and_return(true)
+    end
+
+    it 'does not set the disk move type of the relocation spec' do
+      expect(subject.location.diskMoveType).to be nil
+    end
+  end
+
+  context 'not using linked clones' do
+    before { options[:use_linked_clone] = false }
+
+    it 'does not set the disk move type of the relocation spec' do
+      expect(subject.location.diskMoveType).to be nil
+    end
+  end
+
+  context 'specifying a host' do
+    before { options[:host] = 'host' }
+
+    it 'sets the host' do
+      expect(subject.location.host).to_not be nil
+    end
+  end
+
+  context 'not specifying a host' do
+    it 'does not set the host' do
+      expect(subject.location.host).to be nil
+    end
+  end
+
+  context 'specifying a pool' do
+    before { options[:resource_pool] = 'pool' }
+
+    it 'sets the pool' do
+      expect(subject.location.pool).to_not be nil
+    end
+  end
+
+  context 'not specifying a pool' do
+    it 'does not set the pool' do
+      expect(subject.location.pool).to be nil
+    end
+  end
+
+  context 'not specifying a pool but specifying a host on a template' do
+    before do 
+      options[:host] = 'host'
+      allow(vm_template).to receive_message_chain(:config, :template)
+        .and_return(true)
+    end
+
+    it 'sets the pool to the hosts parent root pool' do
+      expect(subject.location.pool).to be subject.location.host.parent.resourcePool
+    end
+  end
+
+  context 'not specifying a pool or host when cloning from a template' do
+    before do
+      allow(vm_template).to receive_message_chain(:config, :template)
+        .and_return(true)
+    end
+
+    it 'raises an error' do
+      expect { subject }.to raise_error
+    end
+  end
+
+  context 'specifying a hostname' do
+    before do
+      options[:customization_spec] = { 
+        ipsettings: {},
+        hostname: hostname,
+        domain: 'local' 
+      }
+    end
+
+    context 'alpha characters only' do
+      let(:hostname) { 'myhost' }
+
+      it 'sets the spec hostname' do
+        expect(subject.customization.identity.hostName.name).to eq hostname
+      end
+    end
+
+    context 'alpha numeric characters only' do
+      let(:hostname) { 'myhost01' }
+
+      it 'sets the spec hostname' do
+        expect(subject.customization.identity.hostName.name).to eq hostname
+      end
+    end
+
+    context 'containing a dash' do
+      let(:hostname) { 'my-host01' }
+
+      it 'sets the spec hostname' do
+        expect(subject.customization.identity.hostName.name).to eq hostname
+      end
+    end
+
+    context 'containing an underscore' do
+      let(:hostname) { 'my_host' }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+
+    context 'starting with a dash' do
+      let(:hostname) { '-myhost' }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+
+    context 'ending with a dash' do
+      let(:hostname) { 'myhost-' }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end    
+  end
+end

data/spec/unit_tests/support/fake_action_handler.rb

@@ -0,0 +1,7 @@
+module ChefProvisioningVsphereStubs
+  class FakeActionHandler < Chef::Provisioning::ActionHandler
+    def puts(out)
+
+    end
+  end
+end

data/spec/unit_tests/support/vsphere_helper_stub.rb

@@ -0,0 +1,52 @@
+module ChefProvisioningVsphereStubs
+  class VsphereHelperStub < ChefProvisioningVsphere::VsphereHelper
+    def initialize
+    end
+
+    def network_device_changes(action_handler, vm_template, options)
+      [
+        [RbVmomi::VIM::VirtualDeviceConfigSpec.new],
+        [RbVmomi::VIM::VirtualDeviceConfigSpec.new]
+      ]
+    end
+
+    def find_host(host_name)
+      RbVmomi::VIM::HostSystem.new
+    end
+
+    def find_pool(pool_name)
+      RbVmomi::VIM::ResourcePool.new(nil, nil)
+    end
+
+    def find_datastore(datastore_name)
+      RbVmomi::VIM::Datastore.new
+    end
+
+    def find_customization_spec(options)
+      RbVmomi::VIM::CustomizationSpec.new
+    end
+
+    def create_delta_disk(vm_template)
+    end
+  end
+end
+
+module RbVmomi
+  class VIM::HostSystem
+    attr_reader :parent
+
+    def parent
+      @parent ||= RbVmomi::VIM::ComputeResource.new
+    end
+  end
+end
+
+module RbVmomi
+  class VIM::ComputeResource
+    attr_reader :resourcePool
+
+    def resourcePool
+      @resourcePool ||= RbVmomi::VIM::ResourcePool.new(nil, nil)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-vsphere
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.8
 platform: ruby
 authors:
 - CenturyLink Cloud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-09 00:00:00.000000000 Z
+date: 2015-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbvmomi
@@ -103,6 +103,7 @@ files:
 - contribution-notice
 - lib/chef/provisioning/driver_init/vsphere.rb
 - lib/chef/provisioning/vsphere_driver.rb
+- lib/chef/provisioning/vsphere_driver/clone_spec_builder.rb
 - lib/chef/provisioning/vsphere_driver/driver.rb
 - lib/chef/provisioning/vsphere_driver/version.rb
 - lib/chef/provisioning/vsphere_driver/vsphere_helpers.rb
@@ -112,6 +113,9 @@ files:
 - spec/integration_tests/vsphere_driver_spec.rb
 - spec/unit_tests/VsphereDriver_spec.rb
 - spec/unit_tests/VsphereUrl_spec.rb
+- spec/unit_tests/clone_spec_builder_spec.rb
+- spec/unit_tests/support/fake_action_handler.rb
+- spec/unit_tests/support/vsphere_helper_stub.rb
 homepage: https://github.com/tier3/chef-provisioning-vsphere
 licenses:
 - MIT
@@ -141,4 +145,7 @@ test_files:
 - spec/integration_tests/vsphere_driver_spec.rb
 - spec/unit_tests/VsphereDriver_spec.rb
 - spec/unit_tests/VsphereUrl_spec.rb
+- spec/unit_tests/clone_spec_builder_spec.rb
+- spec/unit_tests/support/fake_action_handler.rb
+- spec/unit_tests/support/vsphere_helper_stub.rb
 has_rdoc: