chef-provisioning-vsphere 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d79d0a2cda2ae2c35a26785805165a0449db2ab
-  data.tar.gz: f70880364d9a538115a8b7eeae608971ea9e4246
+  metadata.gz: 990036a8b6dcc42e111ed4acb92aa90c5fe59f1d
+  data.tar.gz: 2767a8e7fd769b90954e57b06eecccfa0fd29736
 SHA512:
-  metadata.gz: 573d1b2bd5a273e6edd62728e1dd7054f6859d7663f6533b0ad69e89b3af02f45fecd6515066751d3b5ac9afa71041bf9941c5c71aedecca1551974c97d4ccf8
-  data.tar.gz: 2ba913e525d49af3799a44aebca5131ebb4eac8f369158f19c8a299d1045017a9697f5c8e1f38b69f28cb683bc9c467ea911836829b1c34a703a5d9282856b75
+  metadata.gz: 0784aeb6843b433d16f5aa93aee499e55ed0aad8b2dd6b8c6378258d9c504ac78fcac3d6cf7e4abdda19e580b6c58ce8a58853db7d2342ab38a943f51e91329c
+  data.tar.gz: e68182faff627baf71b3b0074cc14fac995908123f0bcdef2e263b70cd147496a40fb299b7d9797fd31da826f37176bc7ab9781bd6fb8a2b045a913b6742f0b2

data/Gemfile

@@ -2,4 +2,4 @@
 source "https://rubygems.org"
 gemspec
 
-gem "chef", "~> 12.1"
+gem "chef", "~> 12.3"

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015 CenturyLink
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/chef-provisioning-vsphere.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   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.license = 'MIT'
 
   s.bindir       = 'bin'
   s.executables  = %w( )

data/lib/chef/provisioning/vsphere_driver.rb

@@ -5,9 +5,10 @@ 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
+        url = ChefProvisioningVsphere::VsphereDriver.canonicalize_url(
+          nil, driver_options)[0]
+        with_driver url, driver_options, &block
       end
     end
   end
-end
+end

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

@@ -17,51 +17,20 @@ module ChefProvisioningVsphere
       VsphereDriver.new(driver_url, config)
     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
     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 ]
+      [ driver_url || URI::VsphereUrl.from_config(config).to_s, config ]
     end
 
     def self.symbolize_keys(h)
@@ -73,22 +42,23 @@ module ChefProvisioningVsphere
         ] : 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
+
+      uri = URI(driver_url)
+      @connect_options = { 
+        provider: 'vsphere',
+        host: uri.host,
+        port: uri.port,
+        use_ssl: uri.use_ssl,
+        insecure: uri.insecure,
+        path: uri.path
+      }
+
+      if driver_options
+        @connect_options[:user] = driver_options[:user]
+        @connect_options[:password] = driver_options[:password]
+      end
     end
 
     attr_reader :connect_options
@@ -141,38 +111,38 @@ module ChefProvisioningVsphere
     #
     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..."
+        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"
+          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 ..."
+          Chef::Log.warn machine_msg(
+            machine_spec.name,
+            machine_spec.location['server_id'],
+            'no longer exists.  Recreating ...'
+          )
         end
       end
-      bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
-      vm = nil
+      bootstrap_options = machine_options[:bootstrap_options]
 
-      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
+      action_handler.report_progress full_description(
+        machine_spec, bootstrap_options)
+      
+      vm = find_or_create_vm(bootstrap_options, machine_spec, action_handler)
 
-      description = [ "creating machine #{machine_spec.name} on #{driver_url}" ]
-      bootstrap_options.each_pair { |key,value| description << "  #{key}: #{value.inspect}" }
-      action_handler.report_progress description
+      add_machine_spec_location(vm, machine_spec)
 
-      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
+      action_handler.performed_action(machine_msg(
+        machine_spec.name,
+        vm.config.instanceUuid,
+        'created'
+      ))
+      vm
+    end
 
+    def add_machine_spec_location(vm, machine_spec)
       machine_spec.location = {
         'driver_url' => driver_url,
         'driver_version' => VERSION,
@@ -181,100 +151,199 @@ module ChefProvisioningVsphere
         '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
+    end
 
-      action_handler.performed_action "machine #{machine_spec.name} created as #{machine_spec.location['server_id']} on #{driver_url}"
+    def find_or_create_vm(bootstrap_options, machine_spec, action_handler)
+      vm = find_vm(
+        bootstrap_options[:datacenter],
+        bootstrap_options[:vm_folder],
+        machine_spec.name
+      )
+      server_id = nil
+      if vm
+        Chef::Log.info machine_msg(
+          machine_spec.name,
+          vm.config.instanceUuid,
+          'already created'
+        )
+      else
+        vm = clone_vm(action_handler, bootstrap_options, machine_spec.name)
+      end
       vm
     end
 
+    def full_description(machine_spec, bootstrap_options)
+      description = [ "creating machine #{machine_spec.name} on #{driver_url}" ]
+      bootstrap_options.to_hash.each_pair do |key,value|
+        description << "  #{key}: #{value.inspect}"
+      end
+      description
+    end
+
+    def machine_msg(name, id, action)
+      "Machine - #{action} - #{name} (#{id} on #{driver_url})"
+    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."
+        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 = machine_options[:bootstrap_options]
 
-      bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+      transport_respond?(
+        machine_options,
+        vm,
+        action_handler,
+        machine_spec
+      )
 
-      transport = nil
-      vm_ip = ip_for(bootstrap_options, vm)
-      if !vm_ip.nil?
-        transport = transport_for(machine_spec, machine_options, vm)
+      machine = machine_for(machine_spec,machine_options)
+      setup_extra_nics(action_handler, bootstrap_options, vm, machine)
+
+      if has_static_ip(bootstrap_options) && !is_windows?(vm)
+        setup_ubuntu_dns(machine, bootstrap_options, machine_spec)
       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
+      machine
+    end
 
-        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
+    def setup_extra_nics(action_handler, bootstrap_options, vm, machine)
+      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|
+          nic_label = nic.device.deviceInfo.label
+          machine.execute_always(
+            "Disable-Netadapter -Name '#{nic_label}' -Confirm:$false")
         end
-        machine_spec.location['ipaddress'] = vm.guest.ipAddress
-        action_handler.report_progress "IP address obtained: #{machine_spec.location['ipaddress']}"
       end
+    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
+    def transport_respond?(
+      machine_options,
+      vm,
+      action_handler,
+      machine_spec
+    )
+      bootstrap_options = machine_options[:bootstrap_options]
+
+      # this waits for vmware tools to start and the vm to presebnt an ip
+      # This may just be the ip of a newly cloned machine
+      # Customization below may change this to a valid ip
+      wait_until_ready(action_handler, machine_spec, machine_options, vm)
+      
+      # find the ip we actually want
+      # this will be the static ip to assign
+      # or the ip reported back by the vm if using dhcp
+      # it *may* be nil if just cloned
+      vm_ip = ip_to_bootstrap(bootstrap_options, vm)
+      transport = nil
+      unless vm_ip.nil?
+        transport = transport_for(machine_spec, bootstrap_options[:ssh], vm_ip)
+      end
+
+      unless !transport.nil? && transport.available? && has_ip?(vm_ip, vm)
+        attempt_ip(machine_options, action_handler, vm, machine_spec)
       end
+      machine_spec.location['ipaddress'] = vm.guest.ipAddress
+      action_handler.report_progress(
+        "IP address obtained: #{machine_spec.location['ipaddress']}")
+
+      wait_for_domain(bootstrap_options, vm, machine_spec, action_handler)
 
       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)
+        # 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 ..."
+          Chef::Log.warn(machine_msg(
+            machine_spec.name,
+            vm.config.instanceUuid,
+            'started but SSH did not come up.  Rebooting...'
+          ))
           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
+    end
 
-      machine = machine_for(machine_spec, machine_options, vm)
+    def attempt_ip(machine_options, action_handler, vm, machine_spec)
+      vm_ip = ip_to_bootstrap(machine_options[:bootstrap_options], vm)
+      
+      wait_for_ip(vm, machine_options, action_handler)
+
+      unless has_ip?(vm_ip, vm)
+        action_handler.report_progress "rebooting..."
+        if vm.guest.toolsRunningStatus != "guestToolsRunning"
+          msg = 'tools have stopped. current power state is '
+          msg << vm.runtime.powerState
+          msg << ' and tools state is '
+          msg << vm.guest.toolsRunningStatus
+          msg << '. powering up server...'
+          action_handler.report_progress(msg.join)
+          start_vm(vm)
+        else
+          restart_server(action_handler, machine_spec, vm)
+        end
+        wait_for_ip(vm, machine_options, action_handler)
+      end
+    end
 
-      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")
+    def wait_for_domain(bootstrap_options, vm, machine_spec, action_handler)
+      return unless bootstrap_options[:customization_spec]
+      return unless bootstrap_options[:customization_spec][:domain]
+
+      domain = bootstrap_options[:customization_spec][:domain]
+      if is_windows?(vm) && domain != 'local'
+        start = 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 - start) > 30 ||
+          (vm.guest.hostName == expected_name) do
+          print '.'
+          sleep 5
         end
       end
+    end
 
-      if has_static_ip(bootstrap_options) && !is_windows?(vm)
-        setup_ubuntu_dns(machine, bootstrap_options, machine_spec)
+    def wait_for_ip(vm, machine_options, action_handler)
+      bootstrap_options = machine_options[:bootstrap_options]
+      vm_ip = ip_to_bootstrap(bootstrap_options, vm)
+      ready_timeout = machine_options[:ready_timeout] || 300
+      msg = "waiting up to #{ready_timeout} seconds for customization"
+      msg << " and find #{vm_ip}" unless vm_ip ==  vm.guest.ipAddress
+      action_handler.report_progress msg
+
+      start = Time.now.utc
+      until (Time.now.utc - start) > ready_timeout || has_ip?(vm_ip, vm) do
+        action_handler.report_progress(
+          "IP addresses found: #{all_ips_for(vm)}")
+        vm_ip ||= ip_to_bootstrap(bootstrap_options, vm)
+        sleep 5
       end
+    end
 
-      machine
+    def all_ips_for(vm)
+      vm.guest.net.map { |net| net.ipAddress}.flatten
+    end
+
+    def has_ip?(ip, vm)
+      all_ips_for(vm).include?(ip)
     end
 
     # Connect to machine without acquiring it
@@ -313,8 +382,7 @@ module ChefProvisioningVsphere
       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])
+          start_vm(vm, machine_options[:bootstrap_options][:ssh][:port])
         end
       end
     end
@@ -330,27 +398,27 @@ module ChefProvisioningVsphere
     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
+      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)
@@ -368,18 +436,20 @@ module ChefProvisioningVsphere
 
     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']))
+        (machine_options[:start_timeout] || 600) -
+          (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']))
+        (machine_options[:create_timeout] || 600) - 
+         (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
+          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
@@ -396,32 +466,21 @@ module ChefProvisioningVsphere
       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]
+    def clone_vm(action_handler, bootstrap_options, machine_name)
+      datacenter = bootstrap_options[:datacenter]
 
-      vm = find_vm(datacenter, bootstrap_options[:vm_folder], vm_name)
+      vm = find_vm(datacenter, bootstrap_options[:vm_folder], machine_name)
       return vm if vm
 
       vm_template = vm_template_for(bootstrap_options)
 
-      do_vm_clone(action_handler, datacenter, vm_template, vm_name, bootstrap_options)
+      do_vm_clone(
+        action_handler,
+        datacenter,
+        vm_template,
+        machine_name,
+        bootstrap_options
+      )
     end
 
     def vm_template_for(bootstrap_options)
@@ -431,16 +490,23 @@ module ChefProvisioningVsphere
       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
+    def machine_for(machine_spec, machine_options)
+      if machine_spec.location.nil?
         raise "Server for node #{machine_spec.name} has not been created!"
       end
 
+      transport = transport_for(
+        machine_spec, 
+        machine_options[:bootstrap_options][:ssh]
+      )
+      strategy = convergence_strategy_for(machine_spec, machine_options)
+      
       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))
+        Chef::Provisioning::Machine::WindowsMachine.new(
+          machine_spec, transport, strategy)
       else
-        Chef::Provisioning::Machine::UnixMachine.new(machine_spec, transport_for(machine_spec, machine_options, vm), convergence_strategy_for(machine_spec, machine_options))
+        Chef::Provisioning::Machine::UnixMachine.new(
+          machine_spec, transport, strategy)
       end
     end
 
@@ -466,7 +532,10 @@ module ChefProvisioningVsphere
     end
 
     def wait_for_transport(action_handler, machine_spec, machine_options, vm)
-      transport = transport_for(machine_spec, machine_options, vm)
+      transport = transport_for(
+        machine_spec,
+        machine_options[:bootstrap_options][:ssh]
+      )
       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) ..."
@@ -481,41 +550,48 @@ module ChefProvisioningVsphere
       end
     end
 
-    def transport_for(machine_spec, machine_options, vm)
-      if is_windows?(vm)
-        create_winrm_transport(machine_spec, machine_options, vm)
+    def transport_for(
+      machine_spec, 
+      remoting_options, 
+      ip = machine_spec.location['ipaddress']
+    )
+      if machine_spec.location['is_windows']
+        create_winrm_transport(ip, remoting_options)
       else
-        create_ssh_transport(machine_spec, machine_options, vm)
+        create_ssh_transport(ip, remoting_options)
       end
     end
 
-    def create_winrm_transport(machine_spec, machine_options, vm)
+    def create_winrm_transport(host, options)
       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
+      opt = options[:user].include?("\\") ? :disable_sspi : :basic_auth_only
+      winrm_options = {
+        user: "#{options[:user]}",
+        pass: options[:password],
+        opt => true
+      }
 
-      Chef::Provisioning::Transport::WinRM.new("http://#{remote_host}:5985/wsman", :plaintext, winrm_options, config)
+      Chef::Provisioning::Transport::WinRM.new(
+        "http://#{host}:5985/wsman",
+        :plaintext,
+        winrm_options,
+        config
+      )
     end
 
-    def create_ssh_transport(machine_spec, machine_options, vm)
+    def create_ssh_transport(host, options)
       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)
+      ssh_user = options[:user]
+      Chef::Provisioning::Transport::SSH.new(
+        host,
+        ssh_user,
+        options,
+        {},
+        config
+      )
     end
 
-    def ip_for(bootstrap_options, vm)
+    def ip_to_bootstrap(bootstrap_options, vm)
       if has_static_ip(bootstrap_options)
         bootstrap_options[:customization_spec][:ipsettings][:ip]
       else