chef-metal-vsphere 0.2.0 → 0.3.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8ea8bc26ba359b811ea19cfa5876b688437362b
-  data.tar.gz: 3e37abdd15aed60c1b5ff549ee55b06aaaaac116
+  metadata.gz: 1ab4cff7dadfa8f7cd8fdd608877d2fa4157542f
+  data.tar.gz: 48ec7ddcc3607dd222c59ab81dd7574255d60701
 SHA512:
-  metadata.gz: 5c67f07c76d42ba8804f369651b7ba88a60d9ac14584cd79ebfc8df25138597606872a9150fb8edd3a6cf055162d4937baf629797f204cd98009885f75d9af47
-  data.tar.gz: cd75aac3d3273599f7499e4603155d6cdea53b4135d047c20fa07f9188b36854eb4ad9b93096f35d5d4b4ee18a3ab9e508f808aa8d7e1235399dbec24c5a4eeb
+  metadata.gz: cb74dc9033f4309fbab2f639a44cf82bb48d4182d5344356a2577e27495a35d81ae8d38f687e606987566a357e44bd7566b41c8a5a4e48da4a628ad7574846e5
+  data.tar.gz: 5894d2d4ee3ff44ac50971e4f78c462d55c5cc3e5dce0ba344d01e59d6f7d8622afc10b4f3ce0d950c50a357ea8dd5b24561d210fac261fa92b3e61c84b92e9c

data/.gitignore

@@ -0,0 +1,27 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.vagrant
+**/local-mode-cache
+test/nodes
+test/clients
+.vmonkey

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 0.3.0 (6/15/2014)
+
+- from scratch for chef-metal 0.11
+- uses vmonkey gem for vsphere interactions

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/{LICENSE → LICENSE.txt}

@@ -1,4 +1,6 @@
-Copyright (c) 2014 Rally Software Development Corp
+Copyright (c) 2014 Brian Dupras
+
+MIT License
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +19,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -17,51 +17,40 @@ Create or obtain a unix/linux VM template.  The VM template must:
   - provide access via ssh
   - provide a user account with NOPASSWD sudo
 
+
+### vSphere Credentials
+Create a file called $HOME/.vmonkey.  chef-metal-vsphere uses [vmonkey](https://github.com/vmtricks/vmonkey) to connect to vSphere.  
+
+    host: vcenter_host_name
+    user: vcenter_user_name
+    password: your_mothers_maiden_name
+    datacenter: datacenter_name
+    cluster: cluster_name
+    insecure: true
+    ssl: true
+
+
 ### Example recipe
     require 'chef_metal_vsphere'
-
-    with_vsphere_provisioner vsphere_host: 'vcenter-host-name',
-      vsphere_insecure: true,
-      vsphere_user:     'you_user_name',
-      vsphere_password: 'your_mothers_maiden_name'     # consider using a chef-vault
-
-    with_provisioner_options('bootstrap_options' => {
-      datacenter:         'datacenter_name',
-      cluster:            'cluster_name',
-      resource_pool:      'resource_pool_name',            # often the same as the cluster_name
-      datastore:          'datastore_name',
-      template_name:      'name_of_template_vm',           # may be a VM or a VM Template
-      template_folder:    'folder_containing_template_vm',
-      vm_folder:          'folder_to_clone_vms_into',
-      customization_spec: 'standard-config',               # optional
-
-      ssh: {                                             # net-ssh start() options
-        user:                  'username_on_vm',         # must have nopasswd sudo
-        password:              'name_of_your_first_pet', # consider using a chef-vault
+    with_driver 'vsphere'
+
+    with_machine_options({
+      bootstrap_options: {
+        template: '/path/to/a/vm/template',           # vCenter "VMs and Templates" path to a VM Template
+        folder: '/path/to/a/folder/to/place/new/vms'  # vCenter "VMs and Templates" path to a Folder.  New VMs are created in this folder.
+      },
+      ssh_options: {
+        user:                  'root',                # root or a user with ssh access and NOPASSWD sudo on a VM cloned from the template
+        password:              'your_first_pet',      # consisder using chef-vault
         port:                  22,
-        auth_methods:          ['password'],
-        user_known_hosts_file: '/dev/null',              # don't do this in production
-        paranoid:              false,                    # don't do this in production, either
-        keys:                  [ ],                      # consider using a chef-vault
-        keys_only:             false
-        }
-      })
+        user_known_hosts_file: '/dev/null',           # don't do this in production
+        paranoid:              false                  # don't do this in production, either
+      }
+    })
 
     1.upto 2 do |n|
       machine "metal_#{n}" do
         action [:create]
-
-        ## optionally add options per-machine customizations
-        add_provisioner_options('bootstrap_options' => {
-          num_cpus: n,
-          memory_mb: 1024 * n,
-          annotation: "metal_#{n} created by chef-metal-vsphere"
-        })
-      end
-
-      machine_file "/tmp/metal_#{n}.txt" do
-        machine "metal_#{n}"
-        content "Hello machine #{n}!"
       end
 
       machine "metal_#{n}" do
@@ -75,7 +64,7 @@ Create or obtain a unix/linux VM template.  The VM template must:
 
     end
 
-This will clone your VM template to create two VMware Virtual Machines, "metal_1" and "metal_2", in the vSphere Folder specified by vm_folder, bootstrapped to an empty runlist.  It will then stop (guest shutdown) and delete the vms.
+This will clone your VM template to create two VMware Virtual Machines, "metal_1" and "metal_2", in the vSphere Folder specified by bootstrap_options => folder, bootstrapped to an empty runlist.  It will then stop (guest shutdown) and delete the VMs.
 
 Roadmap
 -------
@@ -85,6 +74,4 @@ Check out [TODO.md](TODO.md)
 Bugs and Contact
 ----------------
 
-Please submit bugs at [chef-metal-vpshere](https://github.com/RallySoftware-cookbooks/chef-metal-vsphere), contact Brian Dupras on Twitter at @briandupras, email at rallysoftware-cookbooks@rallydev.com.
-
-*Warning* if you get an rbvmomi error regarding VMODL::AnyType, add `gem 'nokogiri', '1.5.5'` to your dependencies.
+Please submit bugs at [chef-metal-vpshere](https://github.com/vmtricks/chef-metal-vsphere), contact Brian Dupras on Twitter at @briandupras, email at brian@duprasville.com.

data/Rakefile

@@ -1,30 +1,39 @@
-require 'bundler'
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'mixlib/shellout'
 
-def gem_server
-  @gem_server ||= ENV['GEM_SERVER'] || 'rubygems.org'
+def shell_out(*command_args)
+  cmd = Mixlib::ShellOut.new(command_args)
+  cmd.live_stream = STDOUT
+  cmd.run_command
+  cmd
 end
 
-module Bundler
-  class GemHelper
-    unless gem_server == 'rubygems.org'
-      unless method_defined?(:rubygem_push)
-        raise NoMethodError, "Monkey patching Bundler::GemHelper#rubygem_push failed: did the Bundler API change???"
-      end
-
-      def rubygem_push(path)
-        print "Username: "
-        username = STDIN.gets.chomp
-        print "Password: "
-        password = STDIN.gets.chomp
+def shell_out!(*command_args)
+  cmd = shell_out(*command_args)
+  cmd.error!
+  cmd
+end
 
-        gem_server_url = "https://#{username}:#{password}@#{gem_server}/"
-        sh %{gem push #{path} --host #{gem_server_url}}
+namespace :test do
+  desc 'Run test cookbook in vSphere'
+  task :vsphere do |t|
+    shell_out! %Q{(cd test && chef-client -z -o test::vsphere,test::simple)}
+  end
 
-        Bundler.ui.confirm "Pushed #{name} #{version} to #{gem_server}"
-      end
+  desc 'Run test cookbook in vagrant'
+  task :vagrant do |t|
+    shell_out! %Q{(cd test && chef-client -z -o test::vagrant,test::simple)}
+  end
 
-      puts "Monkey patched Bundler::GemHelper#rubygem_push to push to #{gem_server}."
-    end
+  desc 'Destroy test machines'
+  task :clean do |t|
+    shell_out! %Q{(cd test && chef-client -z -o test::vsphere,test::destroy_all)}
   end
-end
+end
+
+desc 'Run RSpec specs'
+RSpec::Core::RakeTask.new(:spec)  
+
+desc 'Run all tests using vSphere'
+task test: [:spec, 'test:vsphere']

data/TODO.md

@@ -0,0 +1,41 @@
+To Do Items
+===========
+
+Clone features
+--------------
+
+    :bootstrap_options
+      :num_cpus
+      :memory_mb
+      :annotation
+
+      :datastore_cluster
+      :linked_clone
+
+      :customizations
+        :vlan
+        :ips
+        :dns_ips
+        :dns_suffixes
+        :gw
+        :hostname
+        :domain
+        :tz
+
+vApp features
+-------------
+
+  - create/start/stop/delete vApps in recipes
+  - clone from existing vApp
+  - replace machines in vApp
+
+VM features
+-----------
+
+  - markAsTemplate
+
+Usability
+---------
+
+  - create example cookbooks
+  - with test-kitchen tests

data/chef-metal-vpshere.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chef_metal_vsphere/version'
+
+Gem::Specification.new do |spec|
+  spec.name             = 'chef-metal-vsphere'
+  spec.version          = ChefMetalVsphere::VERSION
+  spec.platform         = Gem::Platform::RUBY
+  spec.authors          = ['Brian Dupras']
+  spec.email            = ['brian@duprasville.com']
+  spec.summary          = %q{chef-metal vSphere driver}
+  spec.description      = spec.summary
+  spec.homepage         = 'https://github.com/vmtricks/chef-metal-vsphere'
+  spec.license          = 'MIT'
+
+  spec.require_path     = 'lib'
+  spec.files            = `git ls-files -z`.split("\x0")
+  spec.extra_rdoc_files = ['README.md', 'LICENSE.txt' ]
+  spec.bindir           = 'bin'
+  spec.executables      = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files       = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths    = ['lib']
+
+  spec.add_dependency 'chef', '~> 11.12'
+  spec.add_dependency 'chef-metal', '~> 0.11'
+  spec.add_dependency 'vmonkey', '~> 0.4'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_development_dependency 'mixlib-shellout', '~> 1.4.0'
+  spec.add_development_dependency 'chef-metal-vagrant', '~> 0.4'
+end

data/lib/chef_metal/driver_init/vsphere.rb

@@ -0,0 +1,3 @@
+require 'chef_metal_vsphere/vsphere_driver'
+
+ChefMetal.register_driver_class('vsphere', ChefMetalVsphere::VsphereDriver)

data/lib/chef_metal_vsphere.rb

@@ -1,12 +1,2 @@
 require 'chef_metal'
-require 'chef_metal_vsphere/vsphere_provisioner'
-
-class Chef
-  module DSL
-    module Recipe
-      def with_vsphere_provisioner(options = {}, &block)
-        run_context.chef_metal.with_provisioner(ChefMetalVsphere::VsphereProvisioner.new(options), &block)
-      end
-    end
-  end
-end
+require 'chef_metal_vsphere/vsphere_driver'

data/lib/chef_metal_vsphere/version.rb

@@ -1,3 +1,3 @@
 module ChefMetalVsphere
-  VERSION = '0.2.0'
+  VERSION = '0.3.0.beta.1'
 end

data/lib/chef_metal_vsphere/vsphere_driver.rb

@@ -0,0 +1,325 @@
+require 'chef_metal/driver'
+require 'chef_metal/machine/windows_machine'
+require 'chef_metal/machine/unix_machine'
+require 'chef_metal/machine_spec'
+require 'chef_metal/convergence_strategy/install_msi'
+require 'chef_metal/convergence_strategy/install_sh'
+require 'chef_metal/convergence_strategy/install_cached'
+require 'chef_metal/convergence_strategy/no_converge'
+require 'chef_metal/transport/ssh'
+require 'chef_metal/transport/winrm'
+require 'chef_metal_vsphere/version'
+require 'vmonkey'
+
+module ChefMetalVsphere
+  # Provisions machines in VMware vSphere.
+  class VsphereDriver < ChefMetal::Driver
+    DEFAULT_OPTIONS = {
+      :create_timeout => 300,
+      :start_timeout => 180,
+      :ssh_timeout => 20
+    }
+
+    def self.from_url(url, config)
+      VsphereDriver.new(url, config)
+    end
+
+    def self.canonicalize_url(driver_url, config)
+      _, host, datacenter, cluster = driver_url.split(':', 4)
+      vmonkey_opts = VMonkey.default_opts
+
+      host       ||= vmonkey_opts[:host]
+      datacenter ||= vmonkey_opts[:datacenter]
+      cluster    ||= vmonkey_opts[:cluster]
+
+      [ "vsphere:#{host}:#{datacenter}:#{cluster}", config ]
+    end
+
+    def initialize(url, config)
+      super(url, config)
+    end
+
+    def allocate_machine(action_handler, machine_spec, machine_options)
+      create_vm(action_handler, machine_spec, machine_options)
+    end
+
+    def ready_machine(action_handler, machine_spec, machine_options)
+      vm = vm_for(machine_spec)
+
+      if vm.nil?
+        raise "Machine #{machine_spec.name} does not have a vm associated with it, or vm does not exist."
+      end
+
+      # Start the vm if needed, and wait for it to start
+      start_vm(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)
+
+      machine_for(machine_spec, machine_options, vm)
+    end
+
+    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 "destroy machine #{machine_spec.name} (#{machine_spec.location['instance_uuid']} at #{driver_url})" do
+          vm.destroy
+          machine_spec.location = nil
+        end
+      end
+      strategy = convergence_strategy_for(machine_spec, machine_options)
+      strategy.cleanup_convergence(action_handler, machine_spec)
+    end
+
+    def transport_for(machine_spec, machine_options, vm)
+      # TODO winrm
+      create_ssh_transport(machine_spec, machine_options, vm)
+    end
+
+    protected
+    def option_for(machine_options, key)
+      machine_options[key] || DEFAULT_OPTIONS[key]
+    end
+
+    def monkey
+      ## TODO - test @vim and reconnect on error - idle sessions get silently timed-out by vSphere  :P
+      @vim ||= VMonkey.connect
+    end
+
+    def create_vm(action_handler, machine_spec, machine_options)
+      if machine_spec.location
+        if machine_spec.location['driver_url'] != driver_url
+          raise "Switching a machine's driver from #{machine_spec.location['driver_url']} to #{driver_url} for is not currently supported!  Use machine :destroy and then re-create the machine on the new driver."
+        end
+
+        vm = vm_for!(machine_spec)
+        if vm
+          return vm
+        else
+          Chef::Log.warn "Machine #{machine_spec.name} (#{machine_spec.location['instance_uuid']} on #{driver_url}) no longer exists.  Recreating ..."
+        end
+      end
+
+      bootstrap_options = bootstrap_options_for(action_handler, machine_spec, machine_options)
+
+      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 = nil
+      if action_handler.should_perform_actions
+        template = monkey.vm! bootstrap_options[:template]
+        vm_path = "#{bootstrap_options[:folder]}/#{machine_spec.name}"
+        vm = template.clone_to vm_path
+
+        machine_spec.location = {
+          'driver_url' => driver_url,
+          'driver_version' => ChefMetalVsphere::VERSION,
+          'cloned_from' => bootstrap_options[:template],
+          'path' => vm_path,
+          'instance_uuid' => vm.config.instanceUuid,
+          'allocated_at' => Time.now.to_i
+        }
+        machine_spec.location['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
+        %w(is_windows ssh_username sudo 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 #{vm.config.instanceUuid} on #{driver_url}"
+      end
+      vm
+    end
+
+    def start_vm(action_handler, machine_spec, vm)
+      unless vm.started?
+        action_handler.perform_action "start machine #{machine_spec.name} (#{vm.config.instanceUuid} on #{driver_url})" do
+          vm.start
+          machine_spec.location['started_at'] = Time.now.to_i
+        end
+        machine_spec.save(action_handler)
+      end
+    end
+
+    def remaining_wait_time(machine_spec, machine_options)
+      if machine_spec.location['started_at']
+        timeout = option_for(machine_options, :start_timeout) - (Time.now.utc - parse_time(machine_spec.location['started_at']))
+      else
+        timeout = option_for(machine_options, :create_timeout) - (Time.now.utc - parse_time(machine_spec.location['allocated_at']))
+      end
+      timeout > 0 ? timeout : 0.01
+    end
+
+    def parse_time(value)
+      if value.is_a?(String)
+        Time.parse(value)
+      else
+        Time.at(value)
+      end
+    end
+
+    def wait_until_ready(action_handler, machine_spec, machine_options, vm)
+      unless vm.ready?
+        if action_handler.should_perform_actions
+          action_handler.report_progress "waiting for #{machine_spec.name} (#{vm.config.instanceUuid} on #{driver_url}) to be ready ..."
+          vm.wait_for(remaining_wait_time(machine_spec, machine_options)) { vm.ready? }
+          action_handler.report_progress "#{machine_spec.name} is now ready"
+        end
+      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) ..."
+
+          _self = self
+
+          vm.wait_for(remaining_wait_time(machine_spec, machine_options)) do
+            transport.available?
+          end
+          action_handler.report_progress "#{machine_spec.name} is now connectable"
+        end
+      end
+    end
+
+    def symbolize_keys(options)
+      options.inject({}) do |result,(key,value)|
+        result[key.to_sym] = value
+        result
+      end
+    end
+
+    def vm_for(machine_spec)
+      if machine_spec.location
+        monkey.vm_by_instance_uuid machine_spec.location['instance_uuid']
+      else
+        nil
+      end
+    end
+
+    def vm_for!(machine_spec)
+      monkey.vm_by_instance_uuid! machine_spec.location['instance_uuid']
+    end
+
+    def bootstrap_options_for(action_handler, machine_spec, machine_options)
+      bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
+
+      bootstrap_options[:tags]  = default_tags(machine_spec, bootstrap_options[:tags] || {})
+
+      bootstrap_options[:name] ||= machine_spec.name
+
+      bootstrap_options
+    end
+
+    def default_tags(machine_spec, bootstrap_tags = {})
+      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_tags)
+    end
+
+    def machine_for(machine_spec, machine_options, vm = nil)
+      vm ||= vm_for(machine_spec)
+      if !vm
+        raise "VM for node #{machine_spec.name} has not been created!"
+      end
+
+      if machine_spec.location['is_windows']
+        ChefMetal::Machine::WindowsMachine.new(machine_spec, transport_for(machine_spec, machine_options, vm), convergence_strategy_for(machine_spec, machine_options))
+      else
+        ChefMetal::Machine::UnixMachine.new(machine_spec, transport_for(machine_spec, machine_options, vm), convergence_strategy_for(machine_spec, machine_options))
+      end
+    end
+
+    def convergence_strategy_for(machine_spec, machine_options)
+      # Defaults
+      if !machine_spec.location
+        return ChefMetal::ConvergenceStrategy::NoConverge.new(machine_options[:convergence_options], config)
+      end
+
+      if machine_spec.location['is_windows']
+        ChefMetal::ConvergenceStrategy::InstallMsi.new(machine_options[:convergence_options], config)
+      elsif machine_options[:cached_installer] == true
+        ChefMetal::ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options], config)
+      else
+        ChefMetal::ConvergenceStrategy::InstallSh.new(machine_options[:convergence_options], config)
+      end
+    end
+
+    def ssh_options_for(machine_spec, machine_options, vm)
+      result = {
+        :auth_methods => [ 'publickey' ],
+        :keys_only => true,
+        :host_key_alias => vm.config.instanceUuid
+      }.merge(machine_options[:ssh_options] || {})
+      if vm.respond_to?(:private_key) && vm.private_key
+        result[:key_data] = [ vm.private_key ]
+      elsif vm.respond_to?(:key_name) && vm.key_name
+        key = get_private_key(vm.key_name)
+        if !key
+          raise "VM has key name '#{vm.key_name}', but the corresponding private key was not found locally.  Check if the key is in Chef::Config.private_key_paths: #{Chef::Config.private_key_paths.join(', ')}"
+        end
+        result[:key_data] = [ key ]
+      elsif machine_spec.location['key_name']
+        key = get_private_key(machine_spec.location['key_name'])
+        if !key
+          raise "VM was created with key name '#{machine_spec.location['key_name']}', but the corresponding private key was not found locally.  Check if the key is in Chef::Config.private_key_paths: #{Chef::Config.private_key_paths.join(', ')}"
+        end
+        result[:key_data] = [ key ]
+      elsif machine_options[:bootstrap_options] && machine_options[:bootstrap_options][:key_path]
+        result[:key_data] = [ IO.read(machine_options[:bootstrap_options][:key_path]) ]
+      elsif machine_options[:bootstrap_options] && machine_options[:bootstrap_options][:key_name]
+        result[:key_data] = [ get_private_key(machine_options[:bootstrap_options][:key_name]) ]
+      elsif machine_options[:ssh_options] && machine_options[:ssh_options][:password]
+        result[:password]     = machine_options[:ssh_options][:password]
+        result[:auth_methods] = [ 'password' ]
+        result[:keys]         = [ ]
+        result[:keys_only]    = false
+      else
+        # TODO make a way to suggest other keys to try ...
+        raise "No key or password found to connect to #{machine_spec.name} (#{machine_spec.location.inspect})!  machine_options #{machine_options.inspect}"
+      end
+      result
+    end
+
+    def default_ssh_username(machine_options)
+      if machine_options[:ssh_options] && machine_options[:ssh_options][:user]
+        machine_options[:ssh_options][:user]
+      else
+        'root'
+      end
+    end
+
+    def create_ssh_transport(machine_spec, machine_options, vm)
+      ssh_options = ssh_options_for(machine_spec, machine_options, vm)
+      username = machine_spec.location['ssh_username'] || default_ssh_username(machine_options)
+      if machine_options.has_key?(:ssh_username) && machine_options[:ssh_username] != machine_spec.location['ssh_username']
+        Chef::Log.warn("VM #{machine_spec.name} was created with SSH username #{machine_spec.location['ssh_username']} and machine_options specifies username #{machine_options[:ssh_username]}.  Using #{machine_spec.location['ssh_username']}.  Please edit the node and change the metal.location.ssh_username attribute if you want to change it.")
+      end
+      options = {}
+      if machine_spec.location[:sudo] || (!machine_spec.location.has_key?(:sudo) && username != 'root')
+        options[:prefix] = 'sudo '
+      end
+
+      if vm.guest_ip.nil?
+        raise "VM #{machine_spec.name} (#{vm.config.instanceUuid} has no IP address!"
+      end
+
+      #Enable pty by default
+      options[:ssh_pty_enable] = true
+      options[:ssh_gateway] = machine_spec.location['ssh_gateway'] if machine_spec.location.has_key?('ssh_gateway')
+
+      ChefMetal::Transport::SSH.new(vm.guest_ip, username, ssh_options, options, config)
+    end
+
+  end
+end
+
+