kitchen-vcenter 2.2.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92b3382aeae44f9fd4738c426dd4671a6004ee92c3a6c3a40d9244ac07fe30ea
-  data.tar.gz: 53bb203127b738a42d6cdccf10588778167674424c2f3f5f413334299391334b
+  metadata.gz: 45583a32d2c2ccf32d21491735bbe862c1cc85990ea89bc773a06086a117fc17
+  data.tar.gz: 872abb17f6fd2caf8bbe14f05c31fbe9c402bb065a3c6b010bc8136a944dc525
 SHA512:
-  metadata.gz: cd1808286253bb6922355e0be07fa584bc41b2eec80c076f1cc9e81d138402e6b0de1a1f4aef9802b849ae6ba922f0c7a7278b3736ff9ec6a3bba54fbf0a4afd
-  data.tar.gz: c8521069e9b18129ba8f2e0b0088465f65527f0b01bf351a9ab7c3282b2584a9f42c5ba738884c216988a695bd1170904648940a96e5e7ef925077401ca9aae9
+  metadata.gz: d523aa9288f11454ef5bffd91be68132e3ed34028566af46ddbc85daeb707e05245604477234077a836fbce5e108a1f528b89f65d01653ba62e43ddd94b18747
+  data.tar.gz: c5ee31885c9a12eb0cd9d7e28d2dbb99e0257a897912054ca566aad2cef05f52301ebc65a1e61b588fbbcdf0587982aadfc29e1e72addfa29f2ae9c51a589b8d

data/lib/kitchen-vcenter/version.rb

@@ -20,5 +20,5 @@
 # The main kitchen-vcenter module
 module KitchenVcenter
   # The version of this version of test-kitchen we assume enterprises want.
-  VERSION = "2.2.2"
+  VERSION = "2.4.0"
 end

data/lib/kitchen/driver/vcenter.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-#
 # Author:: Chef Partner Engineering (<partnereng@chef.io>)
 # Copyright:: Copyright (c) 2017 Chef Software, Inc.
 # License:: Apache License, Version 2.0
@@ -53,6 +51,32 @@ module Kitchen
       default_config :vm_rollback, false
       default_config :customize, nil
       default_config :interface, nil
+      default_config :active_discovery, false
+      default_config :active_discovery_command, nil
+      default_config :vm_os, nil
+      default_config :vm_username, "vagrant"
+      default_config :vm_password, "vagrant"
+      default_config :vm_win_network, "Ethernet0"
+
+      default_config :benchmark, false
+      default_config :benchmark_file, "kitchen-vcenter.csv"
+
+      deprecate_config_for :aggressive_mode, Util.outdent!(<<-MSG)
+        The 'aggressive_mode' setting was renamed to 'active_discovery' and
+        will be removed in future versions
+      MSG
+      deprecate_config_for :aggressive_os, Util.outdent!(<<-MSG)
+        The 'aggressive_os' setting was renamed to 'vm_os' and will be
+        removed in future versions.
+      MSG
+      deprecate_config_for :aggressive_username, Util.outdent!(<<-MSG)
+        The 'aggressive_username' setting was renamed to 'vm_username' and will
+        be removed in future versions.
+      MSG
+      deprecate_config_for :aggressive_password, Util.outdent!(<<-MSG)
+        The 'aggressive_password' setting was renamed to 'vm_password' and will
+        be removed in future versions.
+      MSG
 
       # The main create method
       #
@@ -117,12 +141,20 @@ module Kitchen
           datacenter: config[:datacenter],
           folder: config[:folder],
           resource_pool: config[:resource_pool],
-          clone_type: config[:clone_type],
+          clone_type: config[:clone_type].to_sym,
           network_name: config[:network_name],
           interface: config[:interface],
           wait_timeout: config[:vm_wait_timeout],
           wait_interval: config[:vm_wait_interval],
           customize: config[:customize],
+          active_discovery: config[:active_discovery],
+          active_discovery_command: config[:active_discovery_command],
+          vm_os: config[:vm_os],
+          vm_username: config[:vm_username],
+          vm_password: config[:vm_password],
+          vm_win_network: config[:vm_win_network],
+          benchmark: config[:benchmark],
+          benchmark_file: config[:benchmark_file],
         }
 
         begin
@@ -226,6 +258,12 @@ module Kitchen
         # if config[:cluster].nil? && config[:resource_pool].nil?
         #   warn("It is recommended to specify cluster and/or resource_pool to avoid unpredictable machine placement on large deployments")
         # end
+
+        # Process deprecated parameters
+        config[:active_discovery] = config[:aggressive_mode] unless config[:aggressive_mode].nil?
+        config[:vm_os] = config[:aggressive_os] unless config[:aggressive_os].nil?
+        config[:vm_username] = config[:aggressive_username] unless config[:aggressive_username].nil?
+        config[:vm_password] = config[:aggressive_password] unless config[:aggressive_password].nil?
       end
 
       # A helper method to validate the state

data/lib/support/clone_vm.rb

@@ -1,92 +1,360 @@
 require "kitchen"
 require "rbvmomi"
+require "support/guest_operations"
 
 class Support
+  class CloneError < RuntimeError; end
+
   class CloneVm
-    attr_reader :vim, :options, :vm, :name, :path, :ip
+    attr_reader :vim, :options, :ssl_verify, :vm, :name, :ip, :guest_auth, :username
 
     def initialize(conn_opts, options)
       @options = options
       @name = options[:name]
+      @ssl_verify = !conn_opts[:insecure]
 
       # Connect to vSphere
       @vim ||= RbVmomi::VIM.connect conn_opts
+
+      @username = options[:vm_username]
+      password = options[:vm_password]
+      @guest_auth = RbVmomi::VIM::NamePasswordAuthentication(interactiveSession: false, username: username, password: password)
+
+      @benchmark_data = {}
+    end
+
+    def active_discovery?
+      options[:active_discovery] == true
     end
 
-    def get_ip(vm)
-      @ip = nil
+    def ip_from_tools
+      return if vm.guest.net.empty?
 
       # Don't simply use vm.guest.ipAddress to allow specifying a different interface
-      unless vm.guest.net.empty? || !vm.guest.ipAddress
-        nics = vm.guest.net
-        if options[:interface]
-          nics.select! { |nic| nic.network == options[:interface] }
+      nics = vm.guest.net
+      if options[:interface]
+        nics.select! { |nic| nic.network == options[:interface] }
 
-          raise format("No interfaces found on VM which are attached to network '%s'", options[:interface]) if nics.empty?
-        end
+        raise Support::CloneError.new(format("No interfaces found on VM which are attached to network '%s'", options[:interface])) if nics.empty?
+      end
 
-        vm_ip = nil
-        nics.each do |net|
-          vm_ip = net.ipConfig.ipAddress.detect { |addr| addr.origin != "linklayer" }
-          break unless vm_ip.nil?
-        end
+      vm_ip = nil
+      nics.each do |net|
+        vm_ip = net.ipConfig.ipAddress.detect { |addr| addr.origin != "linklayer" }
+        break unless vm_ip.nil?
+      end
+
+      vm_ip&.ipAddress
+    end
+
+    def wait_for_tools(timeout = 30.0, interval = 2.0)
+      start = Time.new
 
-        extended_msg = options[:interface] ? "Network #{options[:interface]}" : ""
-        raise format("No valid IP found on VM %s", extended_msg) if vm_ip.nil?
+      loop do
+        if vm.guest.toolsRunningStatus == "guestToolsRunning"
+          benchmark_checkpoint("tools_detected") if benchmark?
 
-        @ip = vm_ip.ipAddress
+          Kitchen.logger.debug format("Tools detected after %.1f seconds", Time.new - start)
+          return
+        end
+        break if (Time.new - start) >= timeout
+        sleep interval
       end
 
-      ip
+      raise Support::CloneError.new("Timeout waiting for VMware Tools")
     end
 
-    def wait_for_ip(vm, timeout = 30.0, interval = 2.0)
+    def wait_for_ip(timeout = 60.0, interval = 2.0)
       start = Time.new
 
       ip = nil
       loop do
-        ip = get_ip(vm)
-        break if ip || (Time.new - start) >= timeout
+        ip = ip_from_tools
+        if ip || (Time.new - start) >= timeout
+          Kitchen.logger.debug format("IP retrieved after %.1f seconds", Time.new - start) if ip
+          break
+        end
         sleep interval
       end
 
-      raise "Timeout waiting for IP address or no VMware Tools installed on guest" if ip.nil?
-      raise format("Error getting accessible IP address, got %s. Check DHCP server and scope exhaustion", ip) if ip =~ /^169\.254\./
+      raise Support::CloneError.new("Timeout waiting for IP address") if ip.nil?
+      raise Support::CloneError.new(format("Error getting accessible IP address, got %s. Check DHCP server and scope exhaustion", ip)) if ip =~ /^169\.254\./
+
+      @ip = ip
+    end
+
+    def benchmark?
+      options[:benchmark] == true
+    end
+
+    def benchmark_file
+      options[:benchmark_file]
+    end
+
+    def benchmark_start
+      Kitchen.logger.debug("Starting benchmark data collection.")
+
+      @benchmark_data = {
+        template: options[:template],
+        clonetype: options[:clone_type],
+        checkpoints: [
+          { title: "timestamp", value: Time.new.to_f },
+        ],
+      }
+    end
+
+    def benchmark_checkpoint(title)
+      timestamp = Time.new
+      checkpoints = @benchmark_data[:checkpoints]
+
+      total = timestamp - checkpoints.first.fetch(:value)
+      Kitchen.logger.debug format(
+        'Benchmark: Step "%s" at %d (%.1f since start)',
+        title, timestamp, total.to_f
+      )
+
+      @benchmark_data[:checkpoints] << {
+        title: title.to_sym,
+        value: total,
+      }
+    end
+
+    def benchmark_persist
+      # Add total time spent as well
+      checkpoints = @benchmark_data[:checkpoints]
+      checkpoints << {
+        title: :total,
+        value: Time.new - checkpoints.first.fetch(:value),
+      }
+
+      # Include CSV headers
+      unless File.exist?(benchmark_file)
+        header = "template, clonetype, active_discovery, "
+        header += checkpoints.map { |entry| entry[:title] }.join(", ") + "\n"
+        File.write(benchmark_file, header)
+      end
+
+      active_discovery = options[:active_discovery] || instant_clone?
+      data = [@benchmark_data[:template], @benchmark_data[:clonetype], active_discovery.to_s]
+      data << checkpoints.map { |entry| format("%.1f", entry[:value]) }
+
+      file = File.new(benchmark_file, "a")
+      file.puts(data.join(", ") + "\n")
+
+      Kitchen.logger.debug format("Benchmark: Appended data to file %s", benchmark_file)
+    end
+
+    def detect_os
+      vm.config&.guestId&.match(/^win/) ? :windows : :linux
+    end
+
+    def windows?
+      options[:vm_os].downcase.to_sym == :windows
+    end
+
+    def linux?
+      options[:vm_os].downcase.to_sym == :linux
+    end
+
+    def network_device(vm)
+      all_network_devices = vm.config.hardware.device.select do |device|
+        device.is_a?(RbVmomi::VIM::VirtualEthernetCard)
+      end
+
+      # Only support for first NIC so far
+      all_network_devices.first
+    end
+
+    def reconnect_network_device(vm)
+      network_device = network_device(vm)
+      network_device.connectable = RbVmomi::VIM.VirtualDeviceConnectInfo(
+        allowGuestControl: true,
+        startConnected: true,
+        connected: true
+      )
+
+      config_spec = RbVmomi::VIM.VirtualMachineConfigSpec(
+        deviceChange: [
+          RbVmomi::VIM.VirtualDeviceConfigSpec(
+            operation: RbVmomi::VIM::VirtualDeviceConfigSpecOperation("edit"),
+            device: network_device
+          )
+        ]
+      )
+
+      task = vm.ReconfigVM_Task(spec: config_spec)
+      task.wait_for_completion
+
+      benchmark_checkpoint("nic_reconfigured") if benchmark?
+    end
+
+    def standard_ip_discovery
+      Kitchen.logger.info format("Waiting for IP (timeout: %d seconds)...", options[:wait_timeout])
+      wait_for_ip(options[:wait_timeout], options[:wait_interval])
+    end
+
+    def command_separator
+      case options[:vm_os].downcase.to_sym
+      when :linux
+        " && "
+      when :windows
+        " & "
+      end
+    end
+
+    # Rescan network adapters for MAC/IP changes
+    def rescan_commands
+      Kitchen.logger.info "Refreshing network interfaces in OS"
+
+      case options[:vm_os].downcase.to_sym
+      when :linux
+        # @todo: allow override if no dhclient
+        return [
+          "/sbin/modprobe -r vmxnet3",
+          "/sbin/modprobe vmxnet3",
+          "/sbin/dhclient"
+        ]
+      when :windows
+        return [
+          "netsh interface set Interface #{options[:vm_win_network]} disable",
+          "netsh interface set Interface #{options[:vm_win_network]} enable",
+          "ipconfig /renew",
+        ]
+      end
+    end
+
+    # Available from VMware Tools 10.1.0 this pushes the IP instead of the standard 30 second poll
+    # This will be used to provide a quick fallback, if active discovery fails.
+    def trigger_tools
+      case options[:vm_os].downcase.to_sym
+      when :linux
+        [
+          "/usr/bin/vmware-toolbox-cmd info update network"
+        ]
+      when :windows
+        [
+          '"C:\Program Files\VMware\VMware Tools\VMwareToolboxCmd.exe" info update network',
+        ]
+      end
+    end
+
+    # Retrieve IP via OS commands
+    def discovery_commands
+      if options[:active_discovery_command].nil?
+        case options[:vm_os].downcase.to_sym
+        when :linux
+          "ip address show scope global | grep global | cut -b10- | cut -d/ -f1"
+        when :windows
+          ["sleep 5", "ipconfig"]
+          # "ipconfig /renew"
+          # "wmic nicconfig get IPAddress",
+          # "netsh interface ip show ipaddress #{options[:vm_win_network]}"
+        end
+      end
+    end
+
+    def active_ip_discovery(prefix_commands = [])
+      # Instant clone needs this to have synchronous reply on the new IP
+      return unless active_discovery? || instant_clone?
+
+      Kitchen.logger.info "Attempting active IP discovery"
+      begin
+        tools = Support::GuestOperations.new(vim, vm, guest_auth, ssl_verify)
+
+        commands = []
+        commands << rescan_commands if instant_clone?
+        # commands << trigger_tools # deactivated for now, as benefit is doubtful
+        commands << discovery_commands
+        script = commands.flatten.join(command_separator)
+
+        stdout = tools.run_shell_capture_output(script, :auto, 20)
+
+        # Windows returns wrongly encoded UTF-8 for some reason
+        stdout = stdout.bytes.map { |b| (32..126).cover?(b.ord) ? b.chr : nil }.join unless stdout.ascii_only?
+        @ip = stdout.match(/([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})/m)&.captures&.first
+
+        Kitchen.logger.debug format("Script output: %s", stdout)
+        raise Support::CloneError.new(format("Could not find IP in script output, fallback to standard discovery")) if ip.nil?
+        raise Support::CloneError.new(format("Error getting accessible IP address, got %s. Check DHCP server, scope exhaustion or timing issues", ip)) if ip =~ /^169\.254\./
+      rescue RbVmomi::Fault => e
+        if e.fault.class.wsdl_name == "InvalidGuestLogin"
+          message = format('Error authenticating to guest OS as "%s", check configuration of "vm_username"/"vm_password"', username)
+        else
+          message = e.message
+        end
+
+        raise Support::CloneError.new(message)
+      rescue ::StandardError => e
+        Kitchen.logger.info format("Active discovery failed: %s", e.message)
+        return false
+      end
+
+      true
+    end
+
+    def reconfigure_guest
+      Kitchen.logger.info "Waiting for reconfiguration to finish"
+
+      # Pass contents of the customization option/Hash through to allow full customization
+      # https://pubs.vmware.com/vsphere-6-5/index.jsp?topic=%2Fcom.vmware.wssdk.smssdk.doc%2Fvim.vm.ConfigSpec.html
+      config_spec = RbVmomi::VIM.VirtualMachineConfigSpec(options[:customize])
+
+      task = vm.ReconfigVM_Task(spec: config_spec)
+      task.wait_for_completion
+
+      benchmark_checkpoint("reconfigured") if benchmark?
+    end
+
+    def instant_clone?
+      options[:clone_type] == :instant
+    end
+
+    def linked_clone?
+      options[:clone_type] == :linked
+    end
+
+    def full_clone?
+      options[:clone_type] == :full
     end
 
     def clone
+      benchmark_start if benchmark?
+
       # set the datacenter name
       dc = vim.serviceInstance.find_datacenter(options[:datacenter])
 
       # reference template using full inventory path
-      root_folder = @vim.serviceInstance.content.rootFolder
+      root_folder = vim.serviceInstance.content.rootFolder
       inventory_path = format("/%s/vm/%s", options[:datacenter], options[:template])
       src_vm = root_folder.findByInventoryPath(inventory_path)
-      raise format("Unable to find template: %s", options[:template]) if src_vm.nil?
+      raise Support::CloneError.new(format("Unable to find template: %s", options[:template])) if src_vm.nil?
+
+      if src_vm.config.template && !full_clone?
+        Kitchen.logger.warn "Source is a template, thus falling back to full clone. Reference a VM for linked/instant clones."
+        options[:clone_type] = :full
+      end
+
+      if src_vm.snapshot.nil? && !full_clone?
+        Kitchen.logger.warn "Source VM has no snapshot available, thus falling back to full clone. Create a snapshot for linked/instant clones."
+        options[:clone_type] = :full
+      end
 
       # Specify where the machine is going to be created
       relocate_spec = RbVmomi::VIM.VirtualMachineRelocateSpec
 
       # Setting the host is not allowed for instant clone due to VM memory sharing
-      relocate_spec.host = options[:targethost].host unless options[:clone_type] == :instant
+      relocate_spec.host = options[:targethost].host unless instant_clone?
 
       # Change to delta disks for linked clones
-      relocate_spec.diskMoveType = :moveChildMostDiskBacking if options[:clone_type] == :linked
+      relocate_spec.diskMoveType = :moveChildMostDiskBacking if linked_clone?
 
       # Set the resource pool
       relocate_spec.pool = options[:resource_pool]
 
       # Change network, if wanted
       unless options[:network_name].nil?
-        all_network_devices = src_vm.config.hardware.device.select do |device|
-          device.is_a?(RbVmomi::VIM::VirtualEthernetCard)
-        end
-
-        # Only support for first NIC so far
-        network_device = all_network_devices.first
-
         networks = dc.network.select { |n| n.name == options[:network_name] }
-        raise format("Could not find network named %s", option[:network_name]) if networks.empty?
+        raise Support::CloneError.new(format("Could not find network named %s", option[:network_name])) if networks.empty?
 
         Kitchen.logger.warn format("Found %d networks named %s, picking first one", networks.count, options[:network_name]) if networks.count > 1
         network_obj = networks.first
@@ -97,6 +365,7 @@ class Support
           vds_obj = network_obj.config.distributedVirtualSwitch
           Kitchen.logger.info format("Using vDS '%s' for network connectivity...", vds_obj.name)
 
+          network_device = network_device(src_vm)
           network_device.backing = RbVmomi::VIM.VirtualEthernetCardDistributedVirtualPortBackingInfo(
             port: RbVmomi::VIM.DistributedVirtualSwitchPortConnection(
               portgroupKey: network_obj.key,
@@ -110,7 +379,7 @@ class Support
             deviceName: options[:network_name]
           )
         else
-          raise format("Unknown network type %s for network name %s", network_obj.class.to_s, options[:network_name])
+          raise Support::CloneError.new(format("Unknown network type %s for network name %s", network_obj.class.to_s, options[:network_name]))
         end
 
         relocate_spec.deviceChange = [
@@ -125,71 +394,97 @@ class Support
       dest_folder = options[:folder].nil? ? dc.vmFolder : options[:folder][:id]
 
       Kitchen.logger.info format("Cloning '%s' to create the VM...", options[:template])
-      if options[:clone_type] == :instant
+      if instant_clone?
         vcenter_data = vim.serviceInstance.content.about
-        raise "Instant clones only supported with vCenter 6.7 or higher" unless vcenter_data.version.to_f >= 6.7
+        raise Support::CloneError.new("Instant clones only supported with vCenter 6.7 or higher") unless vcenter_data.version.to_f >= 6.7
         Kitchen.logger.debug format("Detected %s", vcenter_data.fullName)
 
         resources = dc.hostFolder.children
         hosts = resources.select { |resource| resource.class.to_s =~ /ComputeResource$/ }.map { |c| c.host }.flatten
         targethost = hosts.select { |host| host.summary.config.name == options[:targethost].name }.first
-        raise "No matching ComputeResource found in host folder" if targethost.nil?
+        raise Support::CloneError.new("No matching ComputeResource found in host folder") if targethost.nil?
 
         esx_data = targethost.summary.config.product
-        raise "Instant clones only supported with ESX 6.7 or higher" unless esx_data.version.to_f >= 6.7
+        raise Support::CloneError.new("Instant clones only supported with ESX 6.7 or higher") unless esx_data.version.to_f >= 6.7
         Kitchen.logger.debug format("Detected %s", esx_data.fullName)
 
         # Other tools check for VMWare Tools status, but that will be toolsNotRunning on frozen VMs
-        raise "Need a running VM for instant clones" unless src_vm.runtime.powerState == "poweredOn"
+        raise Support::CloneError.new("Need a running VM for instant clones") unless src_vm.runtime.powerState == "poweredOn"
 
         # In first iterations, only support the Frozen Source VM workflow. This is more efficient
         #   but needs preparations (freezing the source VM). Running Source VM support is to be
         #   added later
-        raise "Need a frozen VM for instant clones, running source VM not supported yet" unless src_vm.runtime.instantCloneFrozen
+        raise Support::CloneError.new("Need a frozen VM for instant clones, running source VM not supported yet") unless src_vm.runtime.instantCloneFrozen
 
         # Swapping NICs not needed anymore (blog posts mention this), instant clones get a new
         # MAC at least with 6.7.0 build 9433931
 
-        # @todo not working yet
-        # relocate_spec.folder = dest_folder
+        # Disconnect network device, so wo don't get IP collisions on start
+        network_device = network_device(src_vm)
+        network_device.connectable = RbVmomi::VIM.VirtualDeviceConnectInfo(
+          allowGuestControl: true,
+          startConnected: true,
+          connected: false,
+          migrateConnect: "disconnect"
+        )
+        relocate_spec.deviceChange = [
+          RbVmomi::VIM.VirtualDeviceConfigSpec(
+            operation: RbVmomi::VIM::VirtualDeviceConfigSpecOperation("edit"),
+            device: network_device
+          )
+        ]
+
         clone_spec = RbVmomi::VIM.VirtualMachineInstantCloneSpec(location: relocate_spec,
                                                                  name: name)
 
+        benchmark_checkpoint("initialized") if benchmark?
         task = src_vm.InstantClone_Task(spec: clone_spec)
       else
         clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(location: relocate_spec,
                                                           powerOn: options[:poweron] && options[:customize].nil?,
                                                           template: false)
 
+        benchmark_checkpoint("initialized") if benchmark?
         task = src_vm.CloneVM_Task(spec: clone_spec, folder: dest_folder, name: name)
       end
       task.wait_for_completion
 
+      benchmark_checkpoint("cloned") if benchmark?
+
       # get the IP address of the machine for bootstrapping
       # machine name is based on the path, e.g. that includes the folder
-      @path = options[:folder].nil? ? name : format("%s/%s", options[:folder][:name], name)
+      path = options[:folder].nil? ? name : format("%s/%s", options[:folder][:name], name)
       @vm = dc.find_vm(path)
+      raise Support::CloneError.new(format("Unable to find machine: %s", path)) if vm.nil?
 
-      raise format("Unable to find machine: %s", path) if vm.nil?
-
-      # Pass contents of the customization option/Hash through to allow full customization
-      # https://pubs.vmware.com/vsphere-6-5/index.jsp?topic=%2Fcom.vmware.wssdk.smssdk.doc%2Fvim.vm.ConfigSpec.html
-      unless options[:customize].nil?
-        Kitchen.logger.info "Waiting for reconfiguration to finish"
+      if options[:vm_os].nil?
+        os = detect_os
+        Kitchen.logger.debug format('OS for VM not configured, got "%s" from VMware', os.to_s.capitalize)
+        options[:vm_os] = os
+      end
 
-        config_spec = RbVmomi::VIM.VirtualMachineConfigSpec(options[:customize])
-        task = vm.ReconfigVM_Task(spec: config_spec)
-        task.wait_for_completion
+      # Reconnect network device after Instant Clone is ready
+      if instant_clone?
+        Kitchen.logger.info "Reconnecting network adapter"
+        reconnect_network_device(vm)
       end
 
-      if options[:poweron] && !options[:customize].nil? && options[:clone_type] != :instant
+      reconfigure_guest unless options[:customize].nil?
+
+      # Start only if specified or customizations wanted; no need for instant clones as they start in running state
+      if options[:poweron] && !options[:customize].nil? && !instant_clone?
         task = vm.PowerOnVM_Task
         task.wait_for_completion
       end
+      benchmark_checkpoint("powered_on") if benchmark?
+
+      Kitchen.logger.info format("Waiting for VMware tools to become available (timeout: %d seconds)...", options[:wait_timeout])
+      wait_for_tools(options[:wait_timeout], options[:wait_interval])
 
-      Kitchen.logger.info format("Waiting for VMware tools/network interfaces to become available (timeout: %d seconds)...", options[:wait_timeout])
+      active_ip_discovery || standard_ip_discovery
+      benchmark_checkpoint("ip_detected") if benchmark?
 
-      wait_for_ip(vm, options[:wait_timeout], options[:wait_interval])
+      benchmark_persist if benchmark?
       Kitchen.logger.info format("Created machine %s with IP %s", name, ip)
     end
   end

data/lib/support/guest_operations.rb

@@ -0,0 +1,151 @@
+require "rbvmomi"
+require "net/http"
+
+class Support
+  # Encapsulate VMware Tools GOM interaction, inspired by github:dnuffer/raidopt
+  class GuestOperations
+    attr_reader :gom, :vm, :guest_auth, :ssl_verify
+
+    def initialize(vim, vm, guest_auth, ssl_verify = true)
+      @gom = vim.serviceContent.guestOperationsManager
+      @vm = vm
+      @guest_auth = guest_auth
+      @ssl_verify = ssl_verify
+    end
+
+    def os_family
+      return vm.guest.guestFamily == "windowsGuest" ? :windows : :linux if vm.guest.guestFamily
+
+      # VMware tools are not initialized or missing, infer from Guest Id
+      vm.config&.guestId&.match(/^win/) ? :windows : :linux
+    end
+
+    def linux?
+      os_family == :linux
+    end
+
+    def windows?
+      os_family == :windows
+    end
+
+    def delete_dir(dir)
+      gom.fileManager.DeleteDirectoryInGuest(vm: vm, auth: guest_auth, directoryPath: dir, recursive: true)
+    end
+
+    def process_is_running(pid)
+      procs = gom.processManager.ListProcessesInGuest(vm: vm, auth: guest_auth, pids: [pid])
+      procs.empty? || procs.any? { |gpi| gpi.exitCode.nil? }
+    end
+
+    def process_exit_code(pid)
+      gom.processManager.ListProcessesInGuest(vm: vm, auth: guest_auth, pids: [pid])&.first&.exitCode
+    end
+
+    def wait_for_process_exit(pid, timeout = 60.0, interval = 1.0)
+      start = Time.new
+
+      loop do
+        return unless process_is_running(pid)
+        break if (Time.new - start) >= timeout
+        sleep interval
+      end
+
+      raise format("Timeout waiting for process %d to exit after %d seconds", pid, timeout) if (Time.new - start) >= timeout
+    end
+
+    def run_program(path, args = "", timeout = 60.0)
+      Kitchen.logger.debug format("Running %s %s", path, args)
+
+      pid = gom.processManager.StartProgramInGuest(vm: vm, auth: guest_auth, spec: RbVmomi::VIM::GuestProgramSpec.new(programPath: path, arguments: args))
+      wait_for_process_exit(pid, timeout)
+
+      exit_code = process_exit_code(pid)
+      raise format("Failed to run '%s %s'. Exit code: %d", path, args, exit_code) if exit_code != 0
+
+      exit_code
+    end
+
+    def run_shell_capture_output(command, shell = :auto, timeout = 60.0)
+      if shell == :auto
+        shell = :linux if linux?
+        shell = :cmd if windows?
+      end
+
+      if shell == :linux
+        tmp_out_fname = format("/tmp/vm_utils_run_out_%s", Random.rand)
+        tmp_err_fname = format("/tmp/vm_utils_run_err_%s", Random.rand)
+        shell = "/bin/sh"
+        args = format("-c '(%s) > %s 2> %s'", command.gsub("'", %q{\\\'}), tmp_out_fname, tmp_err_fname)
+      elsif shell == :cmd
+        tmp_out_fname = format('C:\Windows\TEMP\vm_utils_run_out_%s', Random.rand)
+        tmp_err_fname = format('C:\Windows\TEMP\vm_utils_run_err_%s', Random.rand)
+        shell = "cmd.exe"
+        args = format('/c "%s > %s 2> %s"', command.gsub("\"", %q{\\\"}), tmp_out_fname, tmp_err_fname)
+      elsif shell == :powershell
+        tmp_out_fname = format('C:\Windows\TEMP\vm_utils_run_out_%s', Random.rand)
+        tmp_err_fname = format('C:\Windows\TEMP\vm_utils_run_err_%s', Random.rand)
+        shell = 'C:\Windows\System32\WindowsPowershell\v1.0\powershell.exe'
+        args = format('-Command "%s > %s 2> %s"', command.gsub("\"", %q{\\\"}), tmp_out_fname, tmp_err_fname)
+      end
+
+      begin
+        exit_code = run_program(shell, args, timeout)
+      rescue StandardError
+        proc_err = "" # read_file(tmp_err_fname)
+        raise format("Error executing command %s. Exit code: %d. StdErr %s", command, exit_code, proc_err)
+      end
+
+      read_file(tmp_out_fname)
+    end
+
+    def write_file(remote_file, contents)
+      # Required privilege: VirtualMachine.GuestOperations.Modify
+      put_url = gom.fileManager.InitiateFileTransferToGuest(
+        vm: vm,
+        auth: guest_auth,
+        guestFilePath: remote_file,
+        fileAttributes: RbVmomi::VIM::GuestFileAttributes(),
+        fileSize: contents.size,
+        overwrite: true
+      )
+      put_url = put_url.gsub(%r{^https://\*:}, format("https://%s:%s", vm._connection.host, put_url))
+      uri = URI.parse(put_url)
+
+      request = Net::HTTP::Put.new(uri.request_uri)
+      request["Transfer-Encoding"] = "chunked"
+      request["Content-Length"] = contents.size
+      request.body = contents
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.verify_mode = ssl_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      http.request(request)
+    end
+
+    def read_file(remote_file)
+      download_file(remote_file, nil)
+    end
+
+    def upload_file(local_file, remote_file)
+      Kitchen.logger.debug format("Copy %s to %s", local_file, remote_file)
+      write_file(remote_file, File.open(local_file, "rb").read)
+    end
+
+    def download_file(remote_file, local_file)
+      info = gom.fileManager.InitiateFileTransferFromGuest(vm: vm, auth: guest_auth, guestFilePath: remote_file)
+      uri = URI.parse(info.url)
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.verify_mode = ssl_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      response = http.request(request)
+
+      if response.body.size != info.size
+        raise format("Downloaded file has different size than reported: %s (%d bytes instead of %d bytes)", remote_file, response.body.size, info.size)
+      end
+
+      local_file.nil? ? response.body : File.open(local_file, "w") { |file| file.write(response.body) }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-vcenter
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.4.0
 platform: ruby
 authors:
 - Chef Software
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-20 00:00:00.000000000 Z
+date: 2019-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbvmomi
@@ -111,6 +111,7 @@ files:
 - lib/kitchen-vcenter/version.rb
 - lib/kitchen/driver/vcenter.rb
 - lib/support/clone_vm.rb
+- lib/support/guest_operations.rb
 homepage: https://github.com/chef/kitchen-vcenter
 licenses:
 - Apache-2.0
@@ -130,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Test Kitchen driver for VMare vCenter