chef-provisioning-vsphere 0.5.7.dev6 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a2f55b3a6433abfdd06aa270db00b1bed0cb8ab
-  data.tar.gz: 74c8800daf24128394246648b0e02540ac0485e8
+  metadata.gz: e7308c027bc21589567543a1144202d7b8868641
+  data.tar.gz: 0f7ce9c37b7ae5662446ca99feb473c61fbbb6ce
 SHA512:
-  metadata.gz: 56b566ca067ed38e6d7b639d6a687468b1189be2693bcd608cd85753d98cba8361009f00e145bf2ee2f9dffc8c766898767787f6f1b9177b73271a5dbc3359ce
-  data.tar.gz: a01d8b591d62cd589569f868e3aa606c1f133f6a099caaab60534628848a56168014d3cd0a95a6722c86d61d8594ca743fe2ff0add2919ca5706ddb99da1cbcf
+  metadata.gz: f9c2f84cabb77cd7cc0540e3a4c648129d97360d4430d2c6ff9d1dd31f1afeb3429191aae723e82c8b2c5c033af5a6e54c779aebf4de851df138ce68a6ae02ec
+  data.tar.gz: 5fa9251bbca1fe98791fe01d27bdf015118d32f5c1832172d0bdf4af075b5fb6d07ba8a13170773628a540852f32d5026c7b3b1e8e374a3a515ca899a2fc2c1e

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

@@ -3,7 +3,6 @@ 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'
@@ -12,6 +11,7 @@ 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 = vsphere_helper.find_vm(
+      vm = 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 = vsphere_helper.add_extra_nic(
+      new_nics = 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)
-          vsphere_helper.start_vm(vm)
+          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
-          vsphere_helper.stop_vm(vm)
+          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
-          vsphere_helper.start_vm(vm, machine_options[:bootstrap_options][:ssh][:port])
+          start_vm(vm, machine_options[:bootstrap_options][:ssh][:port])
         end
       end
       vm
@@ -484,53 +484,25 @@ module ChefProvisioningVsphere
 
     def vm_for(machine_spec)
       if machine_spec.location
-        vsphere_helper.find_vm_by_id(machine_spec.location['server_id'])
+        find_vm_by_id(machine_spec.location['server_id'])
       else
         nil
       end
     end
 
     def clone_vm(action_handler, bootstrap_options, machine_name)
-      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]
+      do_vm_clone(
+        action_handler,
+        vm_template_for(bootstrap_options),
+        machine_name,
+        bootstrap_options
       )
     end
 
     def vm_template_for(bootstrap_options)
       template_folder = bootstrap_options[:template_folder]
       template_name   = bootstrap_options[:template_name]
-      vsphere_helper.find_vm(template_folder, template_name) ||
+      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.dev6'
+  VERSION = '0.5.7'
 end

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

@@ -1,24 +1,16 @@
 require 'rbvmomi'
 
 module ChefProvisioningVsphere
-  class VsphereHelper
+  module Helpers
 
     if !$guest_op_managers
       $guest_op_managers = {}
     end
 
-    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
+    def vim(options = connect_options)
       if @current_connection.nil? or @current_connection.serviceContent.sessionManager.currentSession.nil?
-        puts "establishing connection to #{connect_options[:host]}"
-        @current_connection = RbVmomi::VIM.connect connect_options
+        puts "establishing connection to #{options[:host]}"
+        @current_connection = RbVmomi::VIM.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
@@ -39,14 +31,22 @@ module ChefProvisioningVsphere
       folder.find(vm_name, RbVmomi::VIM::VirtualMachine)
     end
 
-    def find_vm_by_id(uuid)
-      vm = vim.searchIndex.FindByUuid(
+    def find_vm_by_id(uuid, connection = vim)
+      vm = connection.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,6 +70,31 @@ 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
@@ -83,8 +108,9 @@ module ChefProvisioningVsphere
     end
 
     def datacenter
-      @datacenter ||= vim.serviceInstance.find_datacenter(datacenter_name) ||
-        raise("vSphere Datacenter not found [#{datacenter_name}]")
+      dc_name = config[:machine_options][:bootstrap_options][:datacenter]
+      @datacenter ||= vim.serviceInstance.find_datacenter(dc_name) ||
+        raise("vSphere Datacenter not found [#{dc_name}]")
     end
 
     def network_adapter_for(operation, network_name, network_label, device_key, backing_info)
@@ -106,6 +132,56 @@ 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)
 
@@ -130,6 +206,28 @@ 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|
@@ -228,12 +326,114 @@ 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)
@@ -256,28 +456,20 @@ module ChefProvisioningVsphere
 
       raise "vSphere Host not found [#{host_name}]" if host.nil?
 
-      if host.is_a?(RbVmomi::VIM::ComputeResource)
-        host = host.host.first
+      if !host.is_a?(RbVmomi::VIM::HostSystem) && host.respond_to?(:host)
+        host = host.host
       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
-          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 ) }
+        when RbVmomi::VIM::ClusterComputeResource || RbVmomi::VIM::ComputeResource
           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,11 +34,12 @@ 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
@@ -48,11 +49,8 @@ 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']
-      @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)
+      @connection = vim(@metal_config[:driver_options])
+      @vm = find_vm_by_id(@server_id, @connection)
     end
   end
 
@@ -103,7 +101,7 @@ describe 'vsphere_driver' do
       end
     end
     it 'is in the correct datacenter' do
-      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)
+      expect(@connection.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
@@ -148,7 +146,7 @@ describe 'vsphere_driver' do
           @metal_config[:machine_options]
         )
       end
-      vm = @vsphere_helper.find_vm_by_id(@server_id)
+      vm = find_vm_by_id(@server_id, @connection)
       expect(vm).to eq(nil)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-vsphere
 version: !ruby/object:Gem::Version
-  version: 0.5.7.dev6
+  version: 0.5.7
 platform: ruby
 authors:
 - CenturyLink Cloud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-15 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbvmomi
@@ -103,7 +103,6 @@ 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
@@ -113,8 +112,6 @@ 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/vsphere_helper_stub.rb
 homepage: https://github.com/tier3/chef-provisioning-vsphere
 licenses:
 - MIT
@@ -130,9 +127,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.4
@@ -144,6 +141,4 @@ 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/vsphere_helper_stub.rb
 has_rdoc: 

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

@@ -1,200 +0,0 @@
-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)
-      if options.key?(:hostname)
-        RbVmomi::VIM::CustomizationFixedName.new(:name => options[:hostname])
-      else
-        RbVmomi::VIM::CustomizationFixedName.new(:name => vm_name)
-      end
-    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/spec/unit_tests/clone_spec_builder_spec.rb

@@ -1,102 +0,0 @@
-require 'chef/provisioning/vsphere_driver'
-
-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)
-    allow(vm_template).to receive_message_chain(:config, :template)
-      .and_return(false)
-  end
-
-  subject do
-    builder = ChefProvisioningVsphere::CloneSpecBuilder.new(
-      ChefProvisioningVsphereStubs::VsphereHelperStub.new,
-      Chef::Provisioning::ActionHandler.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
-end

data/spec/unit_tests/support/vsphere_helper_stub.rb

@@ -1,52 +0,0 @@
-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