chef-metal-fogsphere 0.1.0.alpha.3 → 0.1.0.alpha.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bded9aeef55e520b6ba1327ca33e5eb587e6a7e3
+  data.tar.gz: fa4cb785cbea11310642c04dced35248a907a27e
+SHA512:
+  metadata.gz: c7090eb59674a2d1d143ad954d5768db3b560a59a5c5fff298d13f5608a8f37b89139561a3f612a574e5ed267239c5e28fc8d08d1677c8ad38849923301c22be
+  data.tar.gz: e27dd63106852b395ca304b5e43b0eba66f2de0cbcb83d71eed7592cc27f2d47af725f3ec713503059a85dc0ed5046f23580f442bd6d05d6a9648ef5efd38cac

data/chef-metal-fogsphere.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
   gem.name          = "chef-metal-fogsphere"
-  gem.version       = '0.1.0.alpha.3'
+  gem.version       = '0.1.0.alpha.4'
   gem.license       = 'Apache 2.0'
   gem.authors       = ["Matt Wrock"]
   gem.email         = ["matt@centurylinkcloud.com"]
@@ -16,5 +16,5 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency 'rbvmomi', '~> 1.5.1'
-  gem.add_dependency 'chef-metal'
+  gem.add_dependency 'chef-metal', '0.11.beta.2'
 end

data/lib/chef_metal/driver_init/vsphere.rb

@@ -0,0 +1,3 @@
+require 'clc_driver'
+
+ChefMetal.register_driver_class("vsphere", ChefMetalVsphere::VsphereDriver)

data/lib/chef_metal_clc.rb

@@ -1,12 +1,15 @@
-require 'chef_metal'
-require 'clc_provisioner'
-
-class Chef
-  module DSL
-    module Recipe
-      def with_vsphere_provisioner(options = {}, &block)
-        run_context.chef_metal.with_provisioner(ChefMetalVsphere::VsphereProvisioner.new({ :provider => 'vsphere' }.merge(options)), &block)
-      end
-    end
-  end
+require 'clc_driver'
+require 'chef_metal'
+
+class Chef
+  module DSL
+    module Recipe
+      def with_vsphere_driver(driver_options = nil, &block)
+        config = Cheffish::MergedConfig.new({ :driver_options => driver_options }, run_context.config)
+        config, id = ChefMetalVsphere::VsphereDriver.compute_options_for(nil, config)
+        config = ChefMetal.config_for_url("vsphere:#{id}", config)
+        run_context.chef_metal.with_driver(ChefMetalVsphere::VsphereDriver.new("vsphere:#{id}", config), &block)
+      end
+    end
+  end
 end

data/lib/clc_driver.rb

@@ -0,0 +1,390 @@
+require 'chef_metal/driver'
+require 'chef_metal/machine/windows_machine'
+require 'chef_metal/machine/unix_machine'
+require 'chef_metal/convergence_strategy/install_msi'
+require 'chef_metal/convergence_strategy/install_cached'
+require 'chef_metal/transport/ssh'
+require 'fog'
+require 'fog/core'
+require 'fog/compute'
+require 'fog/aws'
+
+module ChefMetalVsphere
+  # Provisions machines in vagrant.
+  class VsphereDriver < ChefMetal::Driver
+    include Chef::Mixin::ShellOut
+
+    DEFAULT_OPTIONS = {
+        :create_timeout => 600,
+        :start_timeout => 600,
+        :ssh_timeout => 20
+    } unless defined? DEFAULT_OPTIONS
+
+    def self.from_url(driver_url, config)
+      id = driver_url.split(':')[2]
+      config, id = compute_options_for(id, config)
+      VsphereDriver.new("vsphere:#{id}", config)
+    end
+
+    def self.compute_options_for(id, config)
+      compute_options = config[:driver_options] || {}
+      compute_options[:provider] = 'vsphere'
+      new_config = { :driver_options => { :compute_options => compute_options }}
+
+      # Set the identifier from the URL
+      if id && id != ''
+        compute_options[:vsphere_server] = id
+      end
+
+      config = Cheffish::MergedConfig.new(new_config, config)
+
+      id = compute_options[:vsphere_server]
+
+      [ config, id ]
+    end
+
+    # Create a new fog provisioner.
+    #
+    # ## Parameters
+    # compute_options - hash of options to be passed to Fog::Compute.new
+    # Special options:
+    #   - :base_bootstrap_options is merged with bootstrap_options in acquire_machine
+    #     to present the full set of bootstrap options.  Write down any bootstrap_options
+    #     you intend to apply universally here.
+    #   - :aws_credentials is an AWS CSV file (created with Download Credentials)
+    #     containing your aws key information.  If you don not specify aws_access_key_id
+    #     and aws_secret_access_key explicitly, the first line from this file
+    #     will be used.  You may pass a Cheffish::AWSCredentials object.
+    #   - :create_timeout - the time to wait for the instance to boot to ssh (defaults to 600)
+    #   - :start_timeout - the time to wait for the instance to start (defaults to 600)
+    def initialize(driver_url, config)
+      super(driver_url, config)
+    end
+
+    def compute_options
+      driver_options[:compute_options] || {}
+    end
+
+    def provider
+      compute_options[:provider]
+    end
+
+    # Inflate a provisioner from node_json information; we don't want to force the
+    # driver to figure out what the provisioner really needs, since it varies
+    # from provisioner to provisioner.
+    #
+    # ## Parameters
+    # node_json - node_json to inflate the provisioner for
+    #
+    # returns a FogProvisioner
+    # TODO: def self.inflate(node_json)
+    # right now, not implemented, will raise error from base class until overridden
+
+    # 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_json" property which must be saved to the server (if it is any
+    # different from the original node_json 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_json - node_json object (deserialized json) representing this machine.  If
+    #        the node_json 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_json will have node_json['normal']['provisioner_options'] in it with any options.
+    #        It is a hash with this format:
+    #
+    #           -- provisioner_url: fog:<relevant_fog_options>
+    #           -- bootstrap_options: hash of options to pass to compute.servers.create
+    #           -- is_windows: true if windows.  TODO detect this from ami?
+    #           -- create_timeout - the time to wait for the instance to boot to ssh (defaults to 600)
+    #           -- start_timeout - the time to wait for the instance to start (defaults to 600)
+    #           -- ssh_timeout - the time to wait for ssh to be available if the instance is detected as up (defaults to 20)
+    #
+    #        Example bootstrap_options for ec2:
+    #          'bootstrap_options' => {
+    #            'image_id' =>'ami-311f2b45',
+    #            'flavor_id' =>'t1.micro',
+    #            'key_name' => 'key-pair-name'
+    #          }
+    #
+    #        node_json['normal']['provisioner_output'] will be populated with information
+    #        about the created machine.  For vagrant, it is a hash with this
+    #        format:
+    #
+    #           -- provisioner_url: fog:<relevant_fog_options>
+    #           -- server_id: the ID of the server so it can be found again
+    #
+    def allocate_machine(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
+
+        server = server_for(machine_spec)
+        if server
+          return server
+        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)
+
+      description = [ "creating machine #{machine_spec.name} on #{driver_url}" ]
+      bootstrap_options.each_pair { |key,value| description << "  #{key}: #{value.inspect}" }
+      server = nil
+      action_handler.report_progress description
+
+      clone_results = compute.vm_clone(convert_to_strings(bootstrap_options))
+      server = compute.servers.get(clone_results['new_vm']['id'])
+      if(bootstrap_options[:additional_disk_size_gb] && bootstrap_options[:additional_disk_size_gb].is_a?(Integer) && bootstrap_options[:additional_disk_size_gb] > 0)
+        volume_options = {
+            'server_id' => server.id,
+            'datastore' => bootstrap_options[:datastore],
+            'size_gb' => bootstrap_options[:additional_disk_size_gb]
+        }
+        volume = compute.volumes.create(volume_options)
+      end
+
+      machine_spec.location = {
+        'driver_url' => driver_url,
+        'driver_version' => '0.0.1',
+        'server_id' => server.id,
+        'allocated_at' => Time.now.utc.to_s
+      }
+      machine_spec.location['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
+      %w(is_windows 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 #{server.id} on #{driver_url}"
+      server
+    end
+
+    def ready_machine(action_handler, machine_spec, machine_options)
+      server = server_for(machine_spec)
+      if server.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, server)
+
+      is_static = false
+      bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+      if has_static_ip(bootstrap_options)
+        Chef::Log.info "waiting for customizations to complete"
+        sleep(30)
+        Chef::Log.info "rebooting..."
+        server.reboot
+        is_static = true
+      end
+
+      begin
+        wait_for_transport(action_handler, machine_spec, machine_options, server)
+      rescue Fog::Errors::TimeoutError
+        # 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
+          # Sometimes (on EC2) the machine comes up but gets stuck or has
+          # some other problem.  If this is the case, we restart the server
+          # to unstick it.  Reboot covers a multitude of sins.
+          Chef::Log.warn "Machine #{machine_spec.name} (#{server.id} 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, server)
+          wait_until_ready(action_handler, machine_spec, machine_options, server)
+          wait_for_transport(action_handler, machine_spec, machine_options, server)
+        end
+      end
+
+      machine = machine_for(machine_spec, machine_options, server)
+
+      if is_static
+        interfaces_file = "/etc/network/interfaces"
+        nameservers = "#{bootstrap_options[:primary_dns]} #{bootstrap_options[:secondary_dns]}"
+        machine.execute(action_handler, "if ! cat #{interfaces_file} | grep -q dns-search ; then echo 'dns-search #{machine_spec.name}' >> #{interfaces_file} ; fi")
+        machine.execute(action_handler, "if ! cat #{interfaces_file} | grep -q dns-nameservers ; then echo 'dns-nameservers #{nameservers}' >> #{interfaces_file} ; fi")
+        machine.execute(action_handler, 'echo "ACTION=="add", SUBSYSTEM=="cpu", ATTR{online}="1"" > /etc/udev/rules.d/99-vmware-cpuhotplug-udev.rules')
+        machine.execute(action_handler, '/etc/init.d/networking restart')
+      end
+
+      machine
+    end
+
+    def restart_server(action_handler, machine_spec, server)
+      action_handler.perform_action "restart machine #{machine_spec.name} (#{server.id} on #{driver_url})" do
+        server.reboot
+        machine_spec.location['started_at'] = Time.now.utc.to_s
+      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 convert_to_strings(objay)
+      if objay.kind_of?(Array)
+        objay.map { |v| convert_to_strings(v) }
+      elsif objay.kind_of?(Hash)
+        Hash[objay.map { |(k, v)| [k.to_s, convert_to_strings(v)] }]
+      else
+        objay
+      end
+    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)
+      server = server_for(machine_spec)
+      if server
+        action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
+          server.destroy
+          machine_spec.location = nil
+        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)
+      server = server_for(machine_spec)
+      if server
+        action_handler.perform_action "stop machine #{machine_spec.name} (#{server.id} at #{driver_url})" do
+          server.stop
+        end
+      end
+    end
+
+    def compute
+      @compute ||= Fog::Compute.new(compute_options)
+    end
+
+    # Not meant to be part of public interface
+    def transport_for(machine_spec, machine_options, server)
+      # TODO winrm
+      create_ssh_transport(machine_spec, machine_options, server)
+    end
+
+    protected
+
+    def option_for(machine_options, key)
+      machine_options[key] || DEFAULT_OPTIONS[key]
+    end
+
+    def symbolize_keys(options)
+      options.inject({}) { |result,(key,value)| result[key.to_sym] = value; result }
+    end
+
+    def server_for(machine_spec)
+      if machine_spec.location
+        compute.servers.get(machine_spec.location['server_id'])
+      else
+        nil
+      end
+    end
+
+    def bootstrap_options_for(machine_spec, machine_options)
+      bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
+      if !bootstrap_options[:key_name]
+        bootstrap_options[:key_name] = 'metal_default'
+      end
+      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 machine_for(machine_spec, machine_options, server = nil)
+      server ||= server_for(machine_spec)
+      if !server
+        raise "Server 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, server), convergence_strategy_for(machine_spec, machine_options))
+      else
+        ChefMetal::Machine::UnixMachine.new(machine_spec, transport_for(machine_spec, machine_options, server), 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)
+      else
+        ChefMetal::ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options], config)
+      end
+    end
+
+    def create_ssh_transport(machine_spec, machine_options, server)
+      username = compute_options[:ssh_username] || 'root'
+      bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+      remote_host = has_static_ip(bootstrap_options) ? bootstrap_options[:customization_spec]['ipsettings']['ip'] : server.ipaddress
+      ChefMetal::Transport::SSH.new(remote_host, username, {:password => compute_options[:ssh_password], :paranoid => false}, {}, config)
+    end
+
+    def wait_for_transport(action_handler, machine_spec, machine_options, server)
+      transport = transport_for(machine_spec, machine_options, server)
+      if !transport.available?
+        if action_handler.should_perform_actions
+          action_handler.report_progress "waiting for #{machine_spec.name} (#{server.id} on #{driver_url}) to be connectable (transport up and running) ..."
+
+          _self = self
+
+          server.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 remaining_wait_time(machine_spec, machine_options)
+      if machine_spec.location['started_at']
+        timeout = option_for(machine_options, :start_timeout) - (Time.now.utc - Time.parse(machine_spec.location['started_at']))
+      else
+        timeout = option_for(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, server)
+      if server.tools_state == 'toolsNotRunning'
+        if action_handler.should_perform_actions
+          action_handler.report_progress "waiting for #{machine_spec.name} (#{server.id} on #{driver_url}) to be ready ..."
+          server.wait_for(remaining_wait_time(machine_spec, machine_options)) { tools_state != 'toolsNotRunning' }
+          action_handler.report_progress "#{machine_spec.name} is now ready"
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,48 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal-fogsphere
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha.3
-  prerelease: 6
+  version: 0.1.0.alpha.4
 platform: ruby
 authors:
 - Matt Wrock
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-18 00:00:00.000000000 Z
+date: 2014-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbvmomi
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.1
 - !ruby/object:Gem::Dependency
   name: chef-metal
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.11.beta.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.11.beta.2
 description: A fork of Chef-Metal-fog for vsphere
 email:
 - matt@centurylinkcloud.com
@@ -50,36 +45,35 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - LICENSE
-- chef-metal-fogsphere-0.1.0.alpha.1.zip
 - chef-metal-fogsphere.gemspec
+- lib/chef_metal/driver_init/vsphere.rb
 - lib/chef_metal_clc.rb
-- lib/clc_provisioner.rb
+- lib/clc_driver.rb
 homepage: 
 licenses:
 - Apache 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>'
+  - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.28
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A fork of Chef-Metal-fog for vsphere
 test_files: []
 has_rdoc: 

data/lib/clc_provisioner.rb

@@ -1,419 +0,0 @@
-require 'chef_metal/provisioner'
-require 'chef_metal/aws_credentials'
-require 'chef_metal/openstack_credentials'
-require 'chef_metal/machine/windows_machine'
-require 'chef_metal/machine/unix_machine'
-require 'chef_metal/convergence_strategy/install_msi'
-require 'chef_metal/convergence_strategy/install_cached'
-require 'chef_metal/transport/ssh'
-require 'fog'
-require 'fog/core'
-require 'fog/compute'
-require 'fog/aws'
-
-module ChefMetalVsphere
-  # Provisions machines in vagrant.
-  class VsphereProvisioner < ChefMetal::Provisioner
-    include Chef::Mixin::ShellOut
-
-    DEFAULT_OPTIONS = {
-        :create_timeout => 600,
-        :start_timeout => 600,
-        :ssh_timeout => 20
-    } unless defined? DEFAULT_OPTIONS
-
-    def self.inflate(node_json)
-      url = node_json['normal']['provisioner_output']['provisioner_url']
-      scheme, provider, id = url.split(':', 3)
-      VsphereProvisioner.new({ :provider => provider }, id)
-    end
-
-    # Create a new fog provisioner.
-    #
-    # ## Parameters
-    # compute_options - hash of options to be passed to Fog::Compute.new
-    # Special options:
-    #   - :base_bootstrap_options is merged with bootstrap_options in acquire_machine
-    #     to present the full set of bootstrap options.  Write down any bootstrap_options
-    #     you intend to apply universally here.
-    #   - :aws_credentials is an AWS CSV file (created with Download Credentials)
-    #     containing your aws key information.  If you do not specify aws_access_key_id
-    #     and aws_secret_access_key explicitly, the first line from this file
-    #     will be used.  You may pass a Cheffish::AWSCredentials object.
-    #   - :create_timeout - the time to wait for the instance to boot to ssh (defaults to 600)
-    #   - :start_timeout - the time to wait for the instance to start (defaults to 600)
-    #   - :ssh_timeout - the time to wait for ssh to be available if the instance is detected as up (defaults to 20)
-    # id - the ID in the provisioner_url (fog:PROVIDER:ID)
-    def initialize(compute_options, id=nil)
-      @compute_options = compute_options
-      @base_bootstrap_options = compute_options.delete(:base_bootstrap_options) || {}
-      @base_bootstrap_options_for = {}
-    end
-
-    attr_reader :compute_options
-
-    def current_base_bootstrap_options
-      result = @base_bootstrap_options.dup
-      result
-    end
-
-    # Inflate a provisioner from node_json information; we don't want to force the
-    # driver to figure out what the provisioner really needs, since it varies
-    # from provisioner to provisioner.
-    #
-    # ## Parameters
-    # node_json - node_json to inflate the provisioner for
-    #
-    # returns a FogProvisioner
-    # TODO: def self.inflate(node_json)
-    # right now, not implemented, will raise error from base class until overridden
-
-    # 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_json" property which must be saved to the server (if it is any
-    # different from the original node_json 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_json - node_json object (deserialized json) representing this machine.  If
-    #        the node_json 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_json will have node_json['normal']['provisioner_options'] in it with any options.
-    #        It is a hash with this format:
-    #
-    #           -- provisioner_url: fog:<relevant_fog_options>
-    #           -- bootstrap_options: hash of options to pass to compute.servers.create
-    #           -- is_windows: true if windows.  TODO detect this from ami?
-    #           -- create_timeout - the time to wait for the instance to boot to ssh (defaults to 600)
-    #           -- start_timeout - the time to wait for the instance to start (defaults to 600)
-    #           -- ssh_timeout - the time to wait for ssh to be available if the instance is detected as up (defaults to 20)
-    #
-    #        Example bootstrap_options for ec2:
-    #          'bootstrap_options' => {
-    #            'image_id' =>'ami-311f2b45',
-    #            'flavor_id' =>'t1.micro',
-    #            'key_name' => 'key-pair-name'
-    #          }
-    #
-    #        node_json['normal']['provisioner_output'] will be populated with information
-    #        about the created machine.  For vagrant, it is a hash with this
-    #        format:
-    #
-    #           -- provisioner_url: fog:<relevant_fog_options>
-    #           -- server_id: the ID of the server so it can be found again
-    #
-    def acquire_machine(action_handler, node_json)
-      # Set up the modified node_json data
-      provisioner_output = node_json['normal']['provisioner_output'] || {
-          'provisioner_url' => provisioner_url,
-          'provisioner_version' => '0.0.1'
-      }
-
-      if provisioner_output['provisioner_url'] != provisioner_url
-        raise "Switching a machine's provider from #{provisioner_output['provisioner_url']} to #{provisioner_url} for is not currently supported!  Use machine :destroy and then re-create the machine on the new provisioner."
-      end
-
-      node_json['normal']['provisioner_output'] = provisioner_output
-
-      if provisioner_output['server_id']
-
-        # If the server already exists, make sure it is up
-
-        # TODO verify that the server info matches the specification (ami, etc.)\
-        server = server_for(node_json)
-        if !server
-          Chef::Log.warn "Machine #{node_json['name']} (#{provisioner_output['server_id']} on #{provisioner_url}) is not associated with the ec2 account.  Recreating ..."
-          need_to_create = true
-        elsif server.respond_to?(:state) && %w(terminated archive).include?(server.state) # Can't come back from that
-          Chef::Log.warn "Machine #{node_json['name']} (#{server.id} on #{provisioner_url}) is terminated.  Recreating ..."
-          need_to_create = true
-        else
-          need_to_create = false
-          if !server.ready?
-            action_handler.perform_action "start machine #{node_json['name']} (#{server.id} on #{provisioner_url})" do
-              server.start
-            end
-            action_handler.perform_action "wait for machine #{node_json['name']} (#{server.id} on #{provisioner_url}) to be ready" do
-              wait_until_ready(node_json, server, option_for(node_json, :start_timeout))
-            end
-          else
-            wait_until_ready(node_json, server, option_for(node_json, :ssh_timeout))
-          end
-        end
-      else
-        need_to_create = true
-      end
-
-      if need_to_create
-        # If the server does not exist, create it
-        bootstrap_options = bootstrap_options_for(action_handler.new_resource, node_json)
-        bootstrap_options = bootstrap_options.merge(:name => node_json['name'])
-
-        start_time = Time.now
-        timeout = option_for(node_json, :create_timeout)
-
-        description = [ "create machine #{node_json['name']} on #{provisioner_url}" ]
-        bootstrap_options.each_pair { |key,value| description << "    #{key}: #{value.inspect}" }
-        server = nil
-        action_handler.perform_action description do
-          clone_results = compute.vm_clone(convert_to_strings(bootstrap_options))
-          server = compute.servers.get(clone_results['new_vm']['id'])
-          if(bootstrap_options[:additional_disk_size_gb] && bootstrap_options[:additional_disk_size_gb].is_a?(Integer) && bootstrap_options[:additional_disk_size_gb] > 0)
-            volume_options = {
-                'server_id' => server.id,
-                'datastore' => bootstrap_options[:datastore],
-                'size_gb' => bootstrap_options[:additional_disk_size_gb]
-            }
-            volume = compute.volumes.create(volume_options)
-          end
-          provisioner_output['server_id'] = server.id
-          # Save quickly in case something goes wrong
-          save_node(action_handler, node_json, action_handler.new_resource.chef_server)
-        end
-
-        if server
-          @@ip_pool_lock = Mutex.new
-          # Re-retrieve the server in a more malleable form and wait for it to be ready
-          server = compute.servers.get(server.id)
-          action_handler.perform_action "machine #{node_json['name']} created as #{server.id} on #{provisioner_url}" do
-          end
-          # Wait for the machine to come up
-          Chef::Log.info "waiting for machine to come up"
-          server.wait_for(timeout - (Time.now - start_time)) { tools_state != 'toolsNotRunning' }
-
-          if has_static_ip(node_json)
-            Chef::Log.info "waiting for customizations to complete"
-            sleep(30)
-            Chef::Log.info "rebooting..."
-            server.reboot
-          end
-
-          # wait for ssh to start listening
-          transport = nil
-          _self = self
-          action_handler.perform_action "wait for machine #{node_json['name']} to boot" do
-            server.wait_for(timeout - (Time.now - start_time)) do
-              if tools_state != 'toolsNotRunning'
-                transport ||= _self.transport_for(server, node_json)
-                begin
-                  transport.execute('pwd')
-                  Chef::Log.info "ssh succeeded"
-                  true
-                rescue ChefMetal::Transport::SSH::InitialConnectTimeout, Errno::ECONNREFUSED, Net::SSH::Disconnect, Errno::EHOSTUNREACH => err
-                  Chef::Log.info "ssh failed1: #{err}"
-                  false
-                rescue Exception => e
-                  Chef::Log.info "ssh failed2: #{e}"
-                  true
-                end
-              else
-                false
-              end
-            end
-          end
-
-          # If there is some other error, we just wait patiently for SSH
-          Chef::Log.info "entering next block"
-          begin
-            server.wait_for(option_for(node_json, :ssh_timeout)) { transport.available? }
-          rescue Fog::Errors::TimeoutError
-            # Sometimes (on EC2) the machine comes up but gets stuck or has
-            # some other problem.  If this is the case, we restart the server
-            # to unstick it.  Reboot covers a multitude of sins.
-            Chef::Log.warn "Machine #{node_json['name']} (#{server.id} on #{provisioner_url}) was started but SSH did not come up.  Rebooting machine in an attempt to unstick it ..."
-            action_handler.perform_action "reboot machine #{node_json['name']} to try to unstick it" do
-              server.reboot
-            end
-            Chef::Log.info "rebooted"
-            action_handler.perform_action "wait for machine #{node_json['name']} to be ready after reboot" do
-              wait_until_ready(node_json, server, option_for(node_json, :start_timeout))
-            end
-            Chef::Log.info "reported ready"
-          end
-        end
-      end
-
-      # Create machine object for callers to use
-      machine_for(node_json, server)
-    end
-
-    def has_static_ip(node_json)
-      bootstrap_options = node_json['normal']['provisioner_options']['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 convert_to_strings(objay)
-      if objay.kind_of?(Array)
-        objay.map { |v| convert_to_strings(v) }
-      elsif objay.kind_of?(Hash)
-        Hash[objay.map { |(k, v)| [k.to_s, convert_to_strings(v)] }]
-      else
-        objay
-      end
-    end
-
-    # Connect to machine without acquiring it
-    def connect_to_machine(node_json)
-      machine_for(node_json)
-    end
-
-    def delete_machine(action_handler, node_json)
-      if node_json['normal']['provisioner_output'] && node_json['normal']['provisioner_output']['server_id']
-        server = compute.servers.get(node_json['normal']['provisioner_output']['server_id'])
-        if server
-          action_handler.perform_action "destroy machine #{node_json['name']} (#{node_json['normal']['provisioner_output']['server_id']} at #{provisioner_url})" do
-            server.destroy
-          end
-        end
-        convergence_strategy_for(node_json).cleanup_convergence(action_handler, node_json)
-      end
-    end
-
-    def stop_machine(action_handler, node_json)
-      # If the machine doesn't exist, we silently do nothing
-      if node_json['normal']['provisioner_output'] && node_json['normal']['provisioner_output']['server_id']
-        server = compute.servers.get(node_json['normal']['provisioner_output']['server_id'])
-        action_handler.perform_action "stop machine #{node_json['name']} (#{server.id} at #{provisioner_url})" do
-          server.stop
-        end
-      end
-    end
-
-    def resource_created(machine)
-      @base_bootstrap_options_for[machine] = current_base_bootstrap_options
-    end
-
-    def compute
-      @compute ||= Fog::Compute.new(compute_options)
-    end
-
-    def provisioner_url
-      provider_identifier = compute_options[:vsphere_server]
-      "fog:#{compute_options[:provider]}:#{provider_identifier}"
-    end
-
-    # Not meant to be part of public interface
-    def transport_for(server, node_json = nil)
-      # TODO winrm
-      create_ssh_transport(server, node_json)
-    end
-
-    protected
-
-    def option_for(node_json, key)
-      if node_json['normal']['provisioner_options'] && node_json['normal']['provisioner_options'][key.to_s]
-        node_json['normal']['provisioner_options'][key.to_s]
-      elsif compute_options[key]
-        compute_options[key]
-      else
-        DEFAULT_OPTIONS[key]
-      end
-    end
-
-    def symbolize_keys(options)
-      options.inject({}) { |result,(key,value)| result[key.to_sym] = value; result }
-    end
-
-    def server_for(node_json)
-      if node_json['normal']['provisioner_output'] && node_json['normal']['provisioner_output']['server_id']
-        compute.servers.get(node_json['normal']['provisioner_output']['server_id'])
-      else
-        nil
-      end
-    end
-
-    def bootstrap_options_for(machine, node_json)
-      provisioner_options = node_json['normal']['provisioner_options'] || {}
-      bootstrap_options = @base_bootstrap_options_for[machine] || current_base_bootstrap_options
-      bootstrap_options = bootstrap_options.merge(symbolize_keys(provisioner_options['bootstrap_options'] || {}))
-      require 'socket'
-      require 'etc'
-      tags = {
-          'Name' => node_json['name'],
-          'BootstrapChefServer' => machine.chef_server[:chef_server_url],
-          'BootstrapHost' => Socket.gethostname,
-          'BootstrapUser' => Etc.getlogin,
-          'Bootstrapnode_jsonName' => node_json['name']
-      }
-      if machine.chef_server[:options] && machine.chef_server[:options][:data_store]
-        tags['ChefLocalRepository'] = machine.chef_server[:options][:data_store].chef_fs.fs_description
-      end
-      # User-defined tags override the ones we set
-      tags.merge!(bootstrap_options[:tags]) if bootstrap_options[:tags]
-      bootstrap_options.merge!({ :tags => tags })
-
-      bootstrap_options
-    end
-
-    def machine_for(node_json, server = nil)
-      server ||= server_for(node_json)
-      if !server
-        raise "Server for node_json #{node_json['name']} has not been created!"
-      end
-
-      if node_json['normal']['provisioner_options'] && node_json['normal']['provisioner_options']['is_windows']
-        ChefMetal::Machine::WindowsMachine.new(node_json, transport_for(server, node_json), convergence_strategy_for(node_json))
-      else
-        ChefMetal::Machine::UnixMachine.new(node_json, transport_for(server, node_json), convergence_strategy_for(node_json))
-      end
-    end
-
-    def convergence_strategy_for(node_json)
-      if node_json['normal']['provisioner_options'] && node_json['normal']['provisioner_options']['is_windows']
-        @windows_convergence_strategy ||= begin
-          options = {}
-          provisioner_options = node_json['normal']['provisioner_options'] || {}
-          options[:chef_client_timeout] = provisioner_options['chef_client_timeout'] if provisioner_options.has_key?('chef_client_timeout')
-          ChefMetal::ConvergenceStrategy::InstallMsi.new(options)
-        end
-      else
-        @unix_convergence_strategy ||= begin
-          options = {}
-          provisioner_options = node_json['normal']['provisioner_options'] || {}
-          options[:chef_client_timeout] = provisioner_options['chef_client_timeout'] if provisioner_options.has_key?('chef_client_timeout')
-          ChefMetal::ConvergenceStrategy::InstallCached.new(options)
-        end
-      end
-    end
-
-    def create_ssh_transport(server, node_json)
-      username = compute_options[:ssh_username] || 'root'
-      
-      bootstrap_options = node_json['normal']['provisioner_options']['bootstrap_options']
-      remote_host = has_static_ip(node_json) ? bootstrap_options['customization_spec']['ipsettings']['ip'] : server.ipaddress
-
-      ChefMetal::Transport::SSH.new(remote_host, username, {:password => compute_options[:ssh_password], :paranoid => false}, {})
-    end
-
-    def wait_until_ready(node_json, server, timeout)
-      transport = nil
-      _self = self
-      server.wait_for(timeout) do
-        if transport
-          transport.available?
-        elsif tools_state != 'toolsNotRunning'
-          # Don't create the transport until the machine is ready (we won't have the host till then)
-          transport = _self.transport_for(server, node_json)
-          transport.available?
-        else
-          false
-        end
-      end
-    end
-  end
-end