chef-provisioning-vsphere 0.4.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0d79d0a2cda2ae2c35a26785805165a0449db2ab
+  data.tar.gz: f70880364d9a538115a8b7eeae608971ea9e4246
+SHA512:
+  metadata.gz: 573d1b2bd5a273e6edd62728e1dd7054f6859d7663f6533b0ad69e89b3af02f45fecd6515066751d3b5ac9afa71041bf9941c5c71aedecca1551974c97d4ccf8
+  data.tar.gz: 2ba913e525d49af3799a44aebca5131ebb4eac8f369158f19c8a299d1045017a9697f5c8e1f38b69f28cb683bc9c467ea911836829b1c34a703a5d9282856b75

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/
+Gemfile.lock
+*.gem

data/Gemfile

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+source "https://rubygems.org"
+gemspec
+
+gem "chef", "~> 12.1"

data/README.md

@@ -0,0 +1,79 @@
+chef-provisioning-vsphere
+==================
+
+This is a [chef-provisioning](https://github.com/opscode/chef-provisioning) provisioner for [VMware vSphere](http://www.vmware.com/products/vsphere).
+
+Currently, chef-provisioning-vsphere supports provisioning Unix/ssh and Windows/winrm guest VMs.
+
+Try It Out
+----------
+
+### vSphere VM Template
+
+Create or obtain a VM template.  The VM template must:
+
+  - be capable of installing Chef 11.8 or newer
+  - run vmware-tools on system boot (provides visiblity to ip address of the running VM)
+  - provide access via ssh or winrm
+  - provide a user account with NOPASSWD sudo/administrator
+
+### Example recipe
+
+```
+    chef_gem 'chef-provisioning-vsphere' do
+      action :install
+      compile_time true
+    end
+
+    require 'chef/provisioning/vsphere_driver'
+
+    with_vsphere_driver host: 'vcenter-host-name',
+      insecure: true,
+      user:     'you_user_name',
+      password: 'your_mothers_maiden_name'
+
+    machine_options = {
+      :bootstrap_options => {
+        :num_cpus =>        2,
+        :additional_disk_size_gb => 50,
+        :memory_mb =>       4096,
+        :network_name =>    ["vlan_20_172.21.20"],
+        :datacenter         'datacenter_name',
+        :host:               'cluster/host',
+        :resource_pool:      'cluster/resource_pool_name',
+        :datastore:          'datastore_name',
+        :template_name:      'path to template_vm',           # may be a VM or a VM Template
+        :vm_folder          'folder_to_clone_vms_into',
+        :customization_spec => {
+          :ipsettings => {
+            :ip => '1.2.3.125',
+            :subnetMask => '255.255.255.0',
+            :gateway => ["1.2.3.1"],
+            :dnsServerList => ["1.2.3.31","1.2.3.41"]
+          },
+          :domain => 'local',
+          :domainAdmin => "administrator@local",
+          :domainAdminPassword => "Password",
+          :org_name => 'my_company',
+          :product_id => 'xxxxx-xxxxx-xxxxx-xxxxx-xxxxx',
+          :win_time_zone => 4
+        }
+        :ssh => {
+          :user => 'administrator',
+          :password => 'password',
+          :paranoid => false,
+          :port => 22
+        },
+        :convergence_options => {
+          :install_msi_url=>"https://opscode-omnibus-packages.s3.amazonaws.com/windows/2008r2/x86_64/chef-windows-11.16.4-1.windows.msi", 
+          :install_sh_url=>"/tmp/chef-install.sh -v 11.16.4"
+        }
+      }
+
+      machine "my_machine_name" do
+        machine_options machine_options
+        run_list ['my_cookbook::default']
+      end
+
+```
+

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'chef/provisioning/vsphere_driver/version'
+
+RSpec::Core::RakeTask.new(:unit) do |task|
+  task.pattern = 'spec/unit_tests/*_spec.rb'
+  task.rspec_opts = ['--color', '-f documentation']
+end
+
+RSpec::Core::RakeTask.new(:integration) do |task|
+  task.pattern = 'spec/integration_tests/*_spec.rb'
+  task.rspec_opts = ['--color', '-f documentation']
+end
+
+task :default => [:unit]

data/chef-provisioning-vsphere.gemspec

@@ -0,0 +1,28 @@
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'chef/provisioning/vsphere_driver/version'
+
+Gem::Specification.new do |s|
+  s.name = 'chef-provisioning-vsphere'
+  s.version = ChefProvisioningVsphere::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.extra_rdoc_files = ['README.md']
+  s.summary = 'Provisioner for creating vSphere VM instances in Chef Provisioning.'
+  s.description = s.summary
+  s.authors = ['CenturyLink Cloud']
+  s.email = 'matt.wrock@CenturyLinkCloud.com'
+  s.homepage = 'https://github.com/tier3/chef-provisioning-vsphere'
+  s.license = 'Apache 2.0'
+
+  s.bindir       = 'bin'
+  s.executables  = %w( )
+
+  s.require_path = 'lib'
+  s.files        = `git ls-files -z`.split("\x0")
+  s.test_files   = s.files.grep(%r{^(test|spec|features)/})
+
+  s.add_dependency 'rbvmomi', '~> 1.8.0', '>= 1.8.2'
+  s.add_dependency 'chef-provisioning', '~>1.1'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rake'
+end

data/lib/chef/provisioning/driver_init/vsphere.rb

@@ -0,0 +1,3 @@
+require 'chef/provisioning/vsphere_driver'
+
+Chef::Provisioning.register_driver_class('vsphere', ChefProvisioningVsphere::VsphereDriver)

data/lib/chef/provisioning/vsphere_driver.rb

@@ -0,0 +1,13 @@
+require 'chef/provisioning'
+require 'chef/provisioning/vsphere_driver/driver'
+
+class Chef
+  module DSL
+    module Recipe
+      def with_vsphere_driver(driver_options, &block)
+      	url, config = ChefProvisioningVsphere::VsphereDriver.canonicalize_url(nil, {:driver_options => driver_options})
+  		with_driver url, driver_options, &block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,526 @@
+require 'chef'
+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/version'
+require 'chef/provisioning/vsphere_driver/vsphere_helpers'
+require 'chef/provisioning/vsphere_driver/vsphere_url'
+
+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)
+    end
+
+    def self.canonicalize_url(driver_url, config)
+      config = symbolize_keys(config)
+      new_defaults = {
+       :driver_options => { :connect_options => { :port     => 443,
+                                                  :use_ssl      => true,
+                                                  :insecure => false,
+                                                  :path     => '/sdk'
+        } },
+                       :machine_options => { :start_timeout => 600, 
+                                             :create_timeout => 600, 
+                                             :ready_timeout => 300,
+                                             :bootstrap_options => { :ssh => { :port => 22,
+                                                                               :user => 'root' },
+                                                                     :key_name => 'metal_default',
+                                                                     :tags => {} } }
+      }
+
+      new_connect_options = {}
+      new_connect_options[:provider] = 'vsphere'
+      if !driver_url.nil?
+        uri = URI(driver_url)
+        new_connect_options[:host] = uri.host
+        new_connect_options[:port] = uri.port
+        if uri.path && uri.path.length > 0
+          new_connect_options[:path] = uri.path
+        end
+        new_connect_options[:use_ssl] = uri.use_ssl
+        new_connect_options[:insecure] = uri.insecure
+      end
+      new_connect_options = new_connect_options.merge(config[:driver_options])
+
+      new_config = { :driver_options => { :connect_options => new_connect_options }}
+      config = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+      required_options = [:host, :user, :password]
+      missing_options = []
+      required_options.each do |opt|
+        missing_options << opt unless config[:driver_options][:connect_options].has_key?(opt)
+      end
+      unless missing_options.empty?
+        raise "missing required options: #{missing_options.join(', ')}"
+      end
+
+      url = URI::VsphereUrl.from_config(config[:driver_options][:connect_options]).to_s
+      [ url, config ]
+    end
+
+    def self.symbolize_keys(h)
+      Hash === h ?
+        Hash[
+          h.map do |k, v|
+            [k.respond_to?(:to_sym) ? k.to_sym : k, symbolize_keys(v)]
+          end
+        ] : h
+    end
+
+    # Create a new Vsphere provisioner.
+    #
+    # ## Parameters
+    # connect_options - hash of options to be passed to RbVmomi::VIM.connect
+    #   :host       - required - hostname of the vSphere API server
+    #   :port       - optional - port on the vSphere API server (default: 443)
+    #   :path        - optional - path on the vSphere API server (default: /sdk)
+    #   :use_ssl        - optional - true to use ssl in connection to vSphere API server (default: true)
+    #   :insecure   - optional - true to ignore ssl certificate validation errors in connection to vSphere API server (default: false)
+    #   :user       - required - user name to use in connection to vSphere API server
+    #   :password   - required - password to use in connection to vSphere API server
+    #   :proxy_host         - optional - http proxy host to use in connection to vSphere API server (default: none)
+    #   :proxy_port         - optional - http proxy port to use in connection to vSphere API server (default: none)
+    def initialize(driver_url, config)
+      super(driver_url, config)
+      @connect_options = config[:driver_options][:connect_options].to_hash
+    end
+
+    attr_reader :connect_options
+
+    # Acquire a machine, generally by provisioning it.  Returns a Machine
+    # object pointing at the machine, allowing useful actions like setup,
+    # converge, execute, file and directory.  The Machine object will have a
+    # "node" property which must be saved to the server (if it is any
+    # different from the original node object).
+    #
+    # ## Parameters
+    # action_handler - the action_handler object that is calling this method; this
+    #        is generally a action_handler, but could be anything that can support the
+    #        ChefMetal::ActionHandler interface (i.e., in the case of the test
+    #        kitchen metal driver for acquiring and destroying VMs; see the base
+    #        class for what needs providing).
+    # node - node object (deserialized json) representing this machine.  If
+    #        the node has a provisioner_options hash in it, these will be used
+    #        instead of options provided by the provisioner.  TODO compare and
+    #        fail if different?
+    #        node will have node['normal']['provisioner_options'] in it with any options.
+    #        It is a hash with this format:
+    #
+    #           -- provisioner_url: vsphere://host:port?ssl=[true|false]&insecure=[true|false]
+    #           -- bootstrap_options: hash of options to pass to RbVmomi::VIM::VirtualMachine::CloneTask()
+    #                :datacenter
+    #                :resource_pool
+    #                :cluster
+    #                :datastore
+    #                :template_name
+    #                :template_folder
+    #                :vm_folder
+    #                :winrm {...} (not yet implemented)
+    #                :ssh {...}
+    #
+    #        Example bootstrap_options for vSphere:
+    #          TODO: add other CloneTask params, e.g.: datastore, annotation, resource_pool, ...
+    #          'bootstrap_options' => {
+    #            'template_name' =>'centos6.small',
+    #            'template_folder' =>'Templates',
+    #            'vm_folder' => 'MyApp'
+    #          }
+    #
+    #        node['normal']['provisioner_output'] will be populated with information
+    #        about the created machine.  For vSphere, it is a hash with this
+    #        format:
+    #
+    #           -- provisioner_url: vsphere:host:port?ssl=[true|false]&insecure=[true|false]
+    #           -- vm_folder: name of the vSphere folder containing the VM
+    #
+    def allocate_machine(action_handler, machine_spec, machine_options)
+      if machine_spec.location
+        Chef::Log.warn "Checking to see if #{machine_spec.location} has been created..."
+        vm = vm_for(machine_spec)
+        if vm
+          Chef::Log.warn "returning existing machine"
+          return vm
+        else
+          Chef::Log.warn "Machine #{machine_spec.name} (#{machine_spec.location['server_id']} on #{driver_url}) no longer exists.  Recreating ..."
+        end
+      end
+      bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+      vm = nil
+
+      if bootstrap_options[:ssh]
+        wait_on_port = bootstrap_options[:ssh][:port]
+        raise "Must specify bootstrap_options[:ssh][:port]" if wait_on_port.nil?
+      else
+        raise 'bootstrapping is currently supported for ssh only'
+        # wait_on_port = bootstrap_options['winrm']['port']
+      end
+
+      description = [ "creating machine #{machine_spec.name} on #{driver_url}" ]
+      bootstrap_options.each_pair { |key,value| description << "  #{key}: #{value.inspect}" }
+      action_handler.report_progress description
+
+      vm = find_vm(bootstrap_options[:datacenter], bootstrap_options[:vm_folder], machine_spec.name)
+      server_id = nil
+      if vm
+        Chef::Log.info "machine already created: #{bootstrap_options[:vm_folder]}/#{machine_spec.name}"
+      else
+        vm = clone_vm(action_handler, bootstrap_options)
+      end
+
+      machine_spec.location = {
+        'driver_url' => driver_url,
+        'driver_version' => VERSION,
+        'server_id' => vm.config.instanceUuid,
+        'is_windows' => is_windows?(vm),
+        'allocated_at' => Time.now.utc.to_s,
+        'ipaddress' => vm.guest.ipAddress
+      }
+      machine_spec.location['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
+      %w(ssh_username sudo use_private_ip_for_ssh ssh_gateway).each do |key|
+        machine_spec.location[key] = machine_options[key.to_sym] if machine_options[key.to_sym]
+      end
+
+      action_handler.performed_action "machine #{machine_spec.name} created as #{machine_spec.location['server_id']} on #{driver_url}"
+      vm
+    end
+
+    def ready_machine(action_handler, machine_spec, machine_options)
+      start_machine(action_handler, machine_spec, machine_options)
+      vm = vm_for(machine_spec)
+      if vm.nil?
+        raise "Machine #{machine_spec.name} does not have a server associated with it, or server does not exist."
+      end
+
+      wait_until_ready(action_handler, machine_spec, machine_options, vm)
+
+      bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+
+      transport = nil
+      vm_ip = ip_for(bootstrap_options, vm)
+      if !vm_ip.nil?
+        transport = transport_for(machine_spec, machine_options, vm)
+      end
+
+      if transport.nil? || !transport.available? || !(vm.guest.net.map { |net| net.ipAddress}.flatten).include?(vm_ip)
+        action_handler.report_progress "waiting up to #{machine_options[:ready_timeout]} seconds for customizations to complete and find #{vm_ip}"
+        now = Time.now.utc
+
+        until (Time.now.utc - now) > machine_options[:ready_timeout] || (vm.guest.net.map { |net| net.ipAddress}.flatten).include?(vm_ip) do
+          action_handler.report_progress "IP addresses on #{machine_spec.name} are #{vm.guest.net.map { |net| net.ipAddress}.flatten}"
+          vm_ip = ip_for(bootstrap_options, vm) if vm_ip.nil?
+          sleep 5
+        end
+        if !(vm.guest.net.map { |net| net.ipAddress}.flatten).include?(vm_ip)
+          action_handler.report_progress "rebooting..."
+          if vm.guest.toolsRunningStatus != "guestToolsRunning"
+            action_handler.report_progress "tools have stopped. current power state is #{vm.runtime.powerState} and tools state is #{vm.guest.toolsRunningStatus}. powering up server..."
+            start_vm(vm)
+          else
+            restart_server(action_handler, machine_spec, vm)
+          end
+          now = Time.now.utc
+          until (Time.now.utc - now) > 90 || (vm.guest.net.map { |net| net.ipAddress}.flatten).include?(vm_ip) do
+            vm_ip = ip_for(bootstrap_options, vm) if vm_ip.nil?
+            print "-"
+            sleep 5
+          end
+        end
+        machine_spec.location['ipaddress'] = vm.guest.ipAddress
+        action_handler.report_progress "IP address obtained: #{machine_spec.location['ipaddress']}"
+      end
+
+      domain = bootstrap_options[:customization_spec][:domain]
+      if vm.config.guestId.start_with?('win') && domain != 'local'
+        now = Time.now.utc
+        trimmed_name = machine_spec.name.byteslice(0,15)
+        expected_name="#{trimmed_name}.#{domain}"
+        action_handler.report_progress "waiting to domain join and be named #{expected_name}"
+        until (Time.now.utc - now) > 30 || (vm.guest.hostName == expected_name) do
+          print "."
+          sleep 5
+        end
+      end
+
+      begin
+        wait_for_transport(action_handler, machine_spec, machine_options, vm)
+      rescue Timeout::Error
+        # Only ever reboot once, and only if it's been less than 10 minutes since we stopped waiting
+        if machine_spec.location['started_at'] || remaining_wait_time(machine_spec, machine_options) < -(10*60)
+          raise
+        else
+          Chef::Log.warn "Machine #{machine_spec.name} (#{server.config.instanceUuid} on #{driver_url}) was started but SSH did not come up.  Rebooting machine in an attempt to unstick it ..."
+          restart_server(action_handler, machine_spec, vm)
+          wait_until_ready(action_handler, machine_spec, machine_options, vm)
+          wait_for_transport(action_handler, machine_spec, machine_options, vm)
+        end
+      end
+
+      machine = machine_for(machine_spec, machine_options, vm)
+
+      new_nics = add_extra_nic(action_handler, vm_template_for(bootstrap_options), bootstrap_options, vm)
+      if is_windows?(vm) && !new_nics.nil?
+        new_nics.each do |nic|
+          machine.execute_always("Disable-Netadapter -Name '#{nic.device.deviceInfo.label}' -Confirm:$false")
+        end
+      end
+
+      if has_static_ip(bootstrap_options) && !is_windows?(vm)
+        setup_ubuntu_dns(machine, bootstrap_options, machine_spec)
+      end
+
+      machine
+    end
+
+    # Connect to machine without acquiring it
+    def connect_to_machine(machine_spec, machine_options)
+      machine_for(machine_spec, machine_options)
+    end
+
+    def destroy_machine(action_handler, machine_spec, machine_options)
+      vm = vm_for(machine_spec)
+      if vm
+        action_handler.perform_action "Delete VM [#{vm.parent.name}/#{vm.name}]" do
+          begin
+            vm.PowerOffVM_Task.wait_for_completion unless vm.runtime.powerState == 'poweredOff'
+            vm.Destroy_Task.wait_for_completion
+          rescue RbVmomi::Fault => fault
+            raise fault unless fault.fault.class.wsdl_name == "ManagedObjectNotFound"
+          ensure
+            machine_spec.location = nil
+          end
+        end
+      end
+      strategy = convergence_strategy_for(machine_spec, machine_options)
+      strategy.cleanup_convergence(action_handler, machine_spec)
+    end
+
+    def stop_machine(action_handler, machine_spec, machine_options)
+      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)
+        end
+      end
+    end
+
+    def start_machine(action_handler, machine_spec, machine_options)
+      vm = vm_for(machine_spec)
+      if vm
+        action_handler.perform_action "Power on VM [#{vm.parent.name}/#{vm.name}]" do
+          bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+          start_vm(vm, bootstrap_options[:ssh][:port])
+        end
+      end
+    end
+
+    def restart_server(action_handler, machine_spec, vm)
+      action_handler.perform_action "restart machine #{machine_spec.name} (#{vm.config.instanceUuid} on #{driver_url})" do
+        stop_machine(action_handler, machine_spec, vm)
+        start_vm(vm)
+        machine_spec.location['started_at'] = Time.now.utc.to_s
+      end
+    end
+
+    protected
+
+    def setup_ubuntu_dns(machine, bootstrap_options, machine_spec)
+        host_lookup = machine.execute_always('host google.com')
+        if host_lookup.exitstatus != 0
+          if host_lookup.stdout.include?("setlocale: LC_ALL")
+            machine.execute_always('locale-gen en_US && update-locale LANG=en_US')
+          end
+          distro = machine.execute_always("lsb_release -i | sed -e 's/Distributor ID://g'").stdout.strip
+          Chef::Log.info "Found distro:#{distro}"
+          if distro == 'Ubuntu'
+            distro_version = (machine.execute_always("lsb_release -r | sed -e s/[^0-9.]//g")).stdout.strip.to_f
+            Chef::Log.info "Found distro version:#{distro_version}"
+            if distro_version>= 12.04
+              Chef::Log.info "Ubuntu version 12.04 or greater. Need to patch DNS."
+              interfaces_file = "/etc/network/interfaces"
+              nameservers = bootstrap_options[:customization_spec][:ipsettings][:dnsServerList].join(' ')
+              machine.execute_always("if ! cat #{interfaces_file} | grep -q dns-search ; then echo 'dns-search #{bootstrap_options[:customization_spec][:domain]}' >> #{interfaces_file} ; fi")
+              machine.execute_always("if ! cat #{interfaces_file} | grep -q dns-nameservers ; then echo 'dns-nameservers #{nameservers}' >> #{interfaces_file} ; fi")
+              machine.execute_always('/etc/init.d/networking restart')
+              machine.execute_always('apt-get -qq update')
+            end
+          end
+        end
+    end
+
+    def has_static_ip(bootstrap_options)
+      if bootstrap_options.has_key?(:customization_spec)
+        bootstrap_options = bootstrap_options[:customization_spec]
+        if bootstrap_options.has_key?(:ipsettings)
+          bootstrap_options = bootstrap_options[:ipsettings]
+          if bootstrap_options.has_key?(:ip)
+            return true
+          end
+        end
+      end
+      false
+    end
+
+    def remaining_wait_time(machine_spec, machine_options)
+      if machine_spec.location['started_at']
+        machine_options[:start_timeout] - (Time.now.utc - Time.parse(machine_spec.location['started_at']))
+      else
+        machine_options[:create_timeout] - (Time.now.utc - Time.parse(machine_spec.location['allocated_at']))
+      end
+    end
+
+    def wait_until_ready(action_handler, machine_spec, machine_options, vm)
+      if vm.guest.toolsRunningStatus != "guestToolsRunning"
+        perform_action = true
+        if action_handler.should_perform_actions
+          action_handler.report_progress "waiting for #{machine_spec.name} (#{vm.config.instanceUuid} on #{driver_url}) to be ready ..."
+          until remaining_wait_time(machine_spec, machine_options) < 0 || (vm.guest.toolsRunningStatus == "guestToolsRunning" && (vm.guest.ipAddress.nil? || vm.guest.ipAddress.length > 0)) do
+            print "."
+            sleep 5
+          end
+          action_handler.report_progress "#{machine_spec.name} is now ready"
+        end
+      end
+    end
+
+    def vm_for(machine_spec)
+      if machine_spec.location
+        find_vm_by_id(machine_spec.location['server_id'])
+      else
+        nil
+      end
+    end
+
+    def bootstrap_options_for(machine_spec, machine_options)
+      bootstrap_options = machine_options[:bootstrap_options] || {}
+      bootstrap_options = bootstrap_options.to_hash
+      tags = {
+          'Name' => machine_spec.name,
+          'BootstrapId' => machine_spec.id,
+          'BootstrapHost' => Socket.gethostname,
+          'BootstrapUser' => Etc.getlogin
+      }
+      # User-defined tags override the ones we set
+      tags.merge!(bootstrap_options[:tags]) if bootstrap_options[:tags]
+      bootstrap_options.merge!({ :tags => tags })
+      bootstrap_options[:name] ||= machine_spec.name
+      bootstrap_options
+    end
+
+    def clone_vm(action_handler, bootstrap_options)
+      vm_name         = bootstrap_options[:name]
+      datacenter      = bootstrap_options[:datacenter]
+
+      vm = find_vm(datacenter, bootstrap_options[:vm_folder], vm_name)
+      return vm if vm
+
+      vm_template = vm_template_for(bootstrap_options)
+
+      do_vm_clone(action_handler, datacenter, vm_template, vm_name, bootstrap_options)
+    end
+
+    def vm_template_for(bootstrap_options)
+      datacenter      = bootstrap_options[:datacenter]
+      template_folder = bootstrap_options[:template_folder]
+      template_name   = bootstrap_options[:template_name]
+      find_vm(datacenter, template_folder, template_name) or raise("vSphere VM Template not found [#{template_folder}/#{template_name}]")
+    end
+
+    def machine_for(machine_spec, machine_options, vm = nil)
+      vm ||= vm_for(machine_spec)
+      if !vm
+        raise "Server for node #{machine_spec.name} has not been created!"
+      end
+
+      if machine_spec.location['is_windows']
+        Chef::Provisioning::Machine::WindowsMachine.new(machine_spec, transport_for(machine_spec, machine_options, vm), convergence_strategy_for(machine_spec, machine_options))
+      else
+        Chef::Provisioning::Machine::UnixMachine.new(machine_spec, transport_for(machine_spec, machine_options, vm), convergence_strategy_for(machine_spec, machine_options))
+      end
+    end
+
+    def is_windows?(vm)
+      return false if vm.nil?
+      vm.config.guestId.start_with?('win')
+    end
+
+    def convergence_strategy_for(machine_spec, machine_options)
+      require 'chef/provisioning/convergence_strategy/install_msi'
+      require 'chef/provisioning/convergence_strategy/install_cached'
+      require 'chef/provisioning/convergence_strategy/no_converge'
+      # Defaults
+      if !machine_spec.location
+        return Chef::Provisioning::ConvergenceStrategy::NoConverge.new(machine_options[:convergence_options], config)
+      end
+
+      if machine_spec.location['is_windows']
+        Chef::Provisioning::ConvergenceStrategy::InstallMsi.new(machine_options[:convergence_options], config)
+      else
+        Chef::Provisioning::ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options], config)
+      end
+    end
+
+    def wait_for_transport(action_handler, machine_spec, machine_options, vm)
+      transport = transport_for(machine_spec, machine_options, vm)
+      if !transport.available?
+        if action_handler.should_perform_actions
+          action_handler.report_progress "waiting for #{machine_spec.name} (#{vm.config.instanceUuid} on #{driver_url}) to be connectable (transport up and running) ..."
+
+          until remaining_wait_time(machine_spec, machine_options) < 0 || transport.available? do
+            print "."
+            sleep 5
+          end
+
+          action_handler.report_progress "#{machine_spec.name} is now connectable"
+        end
+      end
+    end
+
+    def transport_for(machine_spec, machine_options, vm)
+      if is_windows?(vm)
+        create_winrm_transport(machine_spec, machine_options, vm)
+      else
+        create_ssh_transport(machine_spec, machine_options, vm)
+      end
+    end
+
+    def create_winrm_transport(machine_spec, machine_options, vm)
+      require 'chef/provisioning/transport/winrm'
+      bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+      ssh_options = bootstrap_options[:ssh]
+      remote_host = machine_spec.location['ipaddress'] || ip_for(bootstrap_options, vm)
+
+      winrm_options = {:user => "#{ssh_options[:user]}", :pass => ssh_options[:password]}
+      if ssh_options[:user].include?("\\")
+        winrm_options[:disable_sspi] = true
+      else
+        winrm_options[:basic_auth_only] = true
+      end
+
+      Chef::Provisioning::Transport::WinRM.new("http://#{remote_host}:5985/wsman", :plaintext, winrm_options, config)
+    end
+
+    def create_ssh_transport(machine_spec, machine_options, vm)
+      require 'chef/provisioning/transport/ssh'
+      bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+      ssh_options = bootstrap_options[:ssh]
+      ssh_user = ssh_options[:user]
+      remote_host = machine_spec.location['ipaddress'] || ip_for(bootstrap_options, vm)
+
+      Chef::Provisioning::Transport::SSH.new(remote_host, ssh_user, ssh_options, {}, config)
+    end
+
+    def ip_for(bootstrap_options, vm)
+      if has_static_ip(bootstrap_options)
+        bootstrap_options[:customization_spec][:ipsettings][:ip]
+      else
+          vm.guest.ipAddress
+      end
+    end
+  end
+end