chef-metal-vagrant 0.3.1 → 0.4.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a07ff0eedf9e89eba8989cdc17243d58432e1ec6
-  data.tar.gz: ff8ac29e8cd1f16e7205d3c0cea531be1834b4d6
+  metadata.gz: 869d2fb17c59772fa9c03e88440319b308bd277d
+  data.tar.gz: 1da119611bf939a3f1c633ab971fbd48699b7361
 SHA512:
-  metadata.gz: e2a033f8c623251ed6e9009dc673f3371bd748ea871710c7921c647d065b56e50efe3a039e56bdc5bb5c9050174778157457ab2c4c21da5fc4f751fbdc43eaf8
-  data.tar.gz: ec2df65a5bf1ebcbeb402b69950a290e6d54b6352744b9174da134cc6328fc50429f413a7f781b1b4620ed961a26475bfdbe907035e8951479dcffcdca9574a4
+  metadata.gz: 22757248dcbc506598c6430e8bba41d15745c98b56fcbcff5beed457b91fa203acf8d105d061c3f8481ddd04809e1ec457e9e629db24e1caed7257c2b35ffac5
+  data.tar.gz: 3236ad050f5bac33de4adc8550036902cae02b0678a1b01b7119ec99b8c20d33d5a2e1f8c5e68b2a30d973b573c9fbfd2047fb9e8a0a832a45ac793865738c51

data/README.md

@@ -1,3 +1,3 @@
 # chef-metal-vagrant
 
-This is the Vagrant provisioner for chef-metal.
+This is the Vagrant driver for chef-metal.

data/lib/chef/provider/vagrant_cluster.rb

@@ -1,10 +1,8 @@
 require 'chef/provider/lwrp_base'
-require 'chef_metal/provider_action_handler'
+require 'cheffish'
 
 class Chef::Provider::VagrantCluster < Chef::Provider::LWRPBase
 
-  include ChefMetal::ProviderActionHandler
-
   use_inline_resources
 
   def whyrun_supported?
@@ -13,7 +11,7 @@ class Chef::Provider::VagrantCluster < Chef::Provider::LWRPBase
 
   action :create do
     the_base_path = new_resource.path
-    ChefMetal.inline_resource(self) do
+    Cheffish.inline_resource(self, :create) do
       directory the_base_path
       file ::File.join(the_base_path, 'Vagrantfile') do
         content <<EOM
@@ -27,7 +25,7 @@ EOM
 
   action :delete do
     the_base_path = new_resource.path
-    ChefMetal.inline_resource(self) do
+    Cheffish.inline_resource(self, :delete) do
       file ::File.join(the_base_path, 'Vagrantfile') do
         action :delete
       end

data/lib/chef/resource/vagrant_box.rb

@@ -9,7 +9,7 @@ class Chef::Resource::VagrantBox < Chef::Resource::LWRPBase
 
   attribute :name, :kind_of => String, :name_attribute => true
   attribute :url, :kind_of => String
-  attribute :provisioner_options, :kind_of => Hash
+  attribute :driver_options, :kind_of => Hash
 
   def after_created
     super

data/lib/chef/resource/vagrant_cluster.rb

@@ -11,6 +11,6 @@ class Chef::Resource::VagrantCluster < Chef::Resource::LWRPBase
 
   def after_created
     super
-    run_context.chef_metal.with_provisioner ChefMetalVagrant::VagrantProvisioner.new(path)
+    run_context.chef_metal.with_driver "vagrant:#{path}"
   end
 end

data/lib/chef_metal/driver_init/vagrant.rb

@@ -0,0 +1,3 @@
+require 'chef_metal_vagrant/vagrant_driver'
+
+ChefMetal.register_driver_class("vagrant", ChefMetalVagrant::VagrantDriver)

data/lib/chef_metal_vagrant/vagrant_driver.rb

@@ -0,0 +1,461 @@
+require 'chef/mixin/shell_out'
+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/winrm'
+require 'chef_metal/transport/ssh'
+require 'chef_metal_vagrant/version'
+require 'chef/resource/vagrant_cluster'
+require 'chef/provider/vagrant_cluster'
+
+module ChefMetalVagrant
+  # Provisions machines in vagrant.
+  class VagrantDriver < ChefMetal::Driver
+
+    include Chef::Mixin::ShellOut
+
+    # Create a new vagrant driver.
+    #
+    # ## Parameters
+    # cluster_path - path to the directory containing the vagrant files, which
+    #                should have been created with the vagrant_cluster resource.
+    def initialize(driver_url, config)
+      super
+      scheme, cluster_path = driver_url.split(':', 2)
+      @cluster_path = cluster_path
+    end
+
+    attr_reader :cluster_path
+
+    def self.from_url(driver_url, config)
+      scheme, cluster_path = driver_url.split(':', 2)
+      cluster_path = File.expand_path(cluster_path || File.join(Chef::Config.config_dir, 'vms'))
+      VagrantDriver.new("vagrant:#{cluster_path}", config)
+    end
+
+    # 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.
+    def allocate_machine(action_handler, machine_spec, machine_options)
+      ensure_vagrant_cluster(action_handler)
+      vm_name = machine_spec.name
+      vm_file_path = File.join(cluster_path, "#{machine_spec.name}.vm")
+      vm_file_updated = create_vm_file(action_handler, vm_name, vm_file_path, machine_options)
+      if vm_file_updated || !machine_spec.location
+        old_location = machine_spec.location
+        machine_spec.location = {
+          'driver_url' => driver_url,
+          'driver_version' => ChefMetalVagrant::VERSION,
+          'vm_name' => vm_name,
+          'vm_file_path' => vm_file_path,
+          'allocated_at' => Time.now.utc.to_s,
+          'host_node' => action_handler.host_node
+        }
+        machine_spec.location['needs_reload'] = true if vm_file_updated
+        if machine_options[:vagrant_options]
+          %w(vm.guest winrm.host winrm.port winrm.username winrm.password).each do |key|
+            machine_spec.location[key] = machine_options[:vagrant_options][key] if machine_options[:vagrant_options][key]
+          end
+        end
+        machine_spec.location['chef_client_timeout'] = machine_options[:chef_client_timeout] if machine_options[:chef_client_timeout]
+      end
+    end
+
+    def ready_machine(action_handler, machine_spec, machine_options)
+      start_machine(action_handler, machine_spec, machine_options)
+      machine_for(machine_spec, machine_options)
+    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)
+      if machine_spec.location
+        vm_name = machine_spec.location['vm_name']
+        current_status = vagrant_status(vm_name)
+        if current_status != 'not created'
+          action_handler.perform_action "run vagrant destroy -f #{vm_name} (status was '#{current_status}')" do
+            result = shell_out("vagrant destroy -f #{vm_name}", :cwd => cluster_path)
+            if result.exitstatus != 0
+              raise "vagrant destroy failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+            end
+          end
+        end
+
+        convergence_strategy_for(machine_spec, machine_options).
+          cleanup_convergence(action_handler, machine_spec)
+
+        vm_file_path = machine_spec.location['vm_file_path']
+        ChefMetal.inline_resource(action_handler) do
+          file vm_file_path do
+            action :delete
+          end
+        end
+      end
+    end
+
+    def stop_machine(action_handler, machine_spec, machine_options)
+      if machine_spec.location
+        vm_name = machine_spec.location['vm_name']
+        current_status = vagrant_status(vm_name)
+        if current_status == 'running'
+          action_handler.perform_action "run vagrant halt #{vm_name} (status was '#{current_status}')" do
+            result = shell_out("vagrant halt #{vm_name}", :cwd => cluster_path)
+            if result.exitstatus != 0
+              raise "vagrant halt failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+            end
+          end
+        end
+      end
+    end
+
+    def ready_machines(action_handler, specs_and_options, parallelizer)
+      start_machines(action_handler, specs_and_options)
+      machines = []
+      specs_and_options.each_pair do |spec, options|
+        machines.push(machine_for(spec, options))
+      end
+      machines
+    end
+
+    def destroy_machines(action_handler, specs_and_options, parallelizer)
+      all_names = []
+      all_status = []
+      all_outputs = {}
+      specs_and_options.each_key do |spec|
+        if spec.location
+          vm_name = spec.location['vm_name']
+          current_status = vagrant_status(vm_name)
+          if current_status != 'not created'
+            all_names.push(vm_name)
+            all_status.push(current_status)
+          end
+        end
+      end
+      if all_names.length > 0
+        names = all_names.join(" ")
+        statuses = all_status.join(", ")
+        action_handler.perform_action "run vagrant destroy -f #{names} (status was '#{statuses}')" do
+          result = shell_out("vagrant destroy -f #{names}", :cwd => cluster_path)
+          if result.exitstatus != 0
+            raise "vagrant destroy failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+          end
+        end
+      end
+      specs_and_options.each_pair do |spec, options|
+        convergence_strategy_for(spec, options).
+          cleanup_convergence(action_handler, spec)
+
+        vm_file_path = spec.location['vm_file_path']
+        ChefMetal.inline_resource(action_handler) do
+          file vm_file_path do
+            action :delete
+          end
+        end
+      end
+    end
+
+    def stop_machines(action_handler, specs_and_options, parallelizer)
+      all_names = []
+      specs_and_options.each_key do |spec|
+        if spec.location
+          vm_name = spec.location['vm_name']
+          current_status = vagrant_status(vm_name)
+          if current_status == 'running'
+            all_names.push(vm_name)
+          end
+        end
+      end
+      if all_names.length > 0
+        names = all_names.join(" ")
+        action_handler.perform_action "run vagrant halt #{names} (status was 'running')" do
+          result = shell_out("vagrant halt #{names}", :cwd => cluster_path)
+          if result.exitstatus != 0
+            raise "vagrant halt failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+          end
+        end
+      end
+    end
+
+    # Used by vagrant_cluster and machine to get the string used to configure vagrant
+    def self.vagrant_config_string(vagrant_config, variable, line_prefix)
+      hostname = name.gsub(/[^A-Za-z0-9\-]/, '-')
+
+      result = ''
+      vagrant_config.each_pair do |key, value|
+        result += "#{line_prefix}#{variable}.#{key} = #{value.inspect}\n"
+      end
+      result
+    end
+
+    def driver_url
+      "vagrant:#{cluster_path}"
+    end
+
+    protected
+
+    def ensure_vagrant_cluster(action_handler)
+      _cluster_path = cluster_path
+      ChefMetal.inline_resource(action_handler) do
+        vagrant_cluster _cluster_path
+      end
+    end
+
+    def create_vm_file(action_handler, vm_name, vm_file_path, machine_options)
+      # Determine contents of vm file
+      vm_file_content = "Vagrant.configure('2') do |outer_config|\n"
+      vm_file_content << "  outer_config.vm.define #{vm_name.inspect} do |config|\n"
+      merged_vagrant_options = { 'vm.hostname' => vm_name }
+      if machine_options[:vagrant_options]
+        merged_vagrant_options = Cheffish::MergedConfig.new(machine_options[:vagrant_options], merged_vagrant_options)
+      end
+      merged_vagrant_options.each_pair do |key, value|
+        vm_file_content << "    config.#{key} = #{value.inspect}\n"
+      end
+      vm_file_content << machine_options[:vagrant_config] if machine_options[:vagrant_config]
+      vm_file_content << "  end\nend\n"
+
+      # Set up vagrant file
+      ChefMetal.inline_resource(action_handler) do
+        file vm_file_path do
+          content vm_file_content
+          action :create
+        end
+      end
+    end
+
+    def start_machine(action_handler, machine_spec, machine_options)
+      vm_name = machine_spec.location['vm_name']
+      up_timeout = machine_options[:up_timeout] || 10*60
+
+      current_status = vagrant_status(vm_name)
+      vm_file_updated = machine_spec.location['needs_reload']
+      machine_spec.location['needs_reload'] = false
+      if current_status != 'running'
+        # Run vagrant up if vm is not running
+        action_handler.perform_action "run vagrant up #{vm_name} (status was '#{current_status}')" do
+          result = shell_out("vagrant up #{vm_name}", :cwd => cluster_path,
+            :timeout => up_timeout)
+          if result.exitstatus != 0
+            raise "vagrant up #{vm_name} failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+          end
+          parse_vagrant_up(result.stdout, machine_spec)
+        end
+      elsif vm_file_updated
+        # Run vagrant reload if vm is running and vm file changed
+        action_handler.perform_action "run vagrant reload #{vm_name}" do
+          result = shell_out("vagrant reload #{vm_name}", :cwd => cluster_path,
+            :timeout => up_timeout)
+          if result.exitstatus != 0
+            raise "vagrant reload #{vm_name} failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+          end
+          parse_vagrant_up(result.stdout, machine_spec)
+        end
+      end
+    end
+
+    def start_machines(action_handler, specs_and_options)
+      up_names = []
+      up_status = []
+      up_specs = {}
+      update_names = []
+      update_specs = {}
+      timeouts = []
+      specs_and_options.each_pair do |spec, options|
+        vm_name = spec.location['vm_name']
+
+        vm_file_updated = spec.location['needs_reload']
+        spec.location['needs_reload'] = false
+
+        current_status = vagrant_status(vm_name)
+        if current_status != 'running'
+          up_names.push(vm_name)
+          up_status.push(current_status)
+          up_specs[vm_name] = spec
+        elsif vm_file_updated
+          update_names.push(vm_name)
+          update_specs[vm_name] = spec
+        end
+        timeouts.push(options[:up_timeout])
+      end
+      # Use the highest timeout, if any exist
+      up_timeout = timeouts.compact.max
+      up_timeout ||= 10*60
+      if up_names.length > 0
+        # Run vagrant up if vm is not running
+        names = up_names.join(" ")
+        statuses = up_status.join(", ")
+        action_handler.perform_action "run vagrant up --parallel #{names} (status was '#{statuses}')" do
+          result = shell_out("vagrant up --parallel #{names}", :cwd => cluster_path,
+            :timeout => up_timeout)
+          if result.exitstatus != 0
+            raise "vagrant up #{names} failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+          end
+          parse_multi_vagrant_up(result.stdout, up_specs)
+        end
+      end
+      if update_names.length > 0
+        names = update_names.join(" ")
+        # Run vagrant reload if vm is running and vm file changed
+        action_handler.perform_action "run vagrant reload #{names}" do
+          result = shell_out("vagrant reload #{names}", :cwd => cluster_path,
+            :timeout => up_timeout)
+          if result.exitstatus != 0
+            raise "vagrant reload #{names} failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+          end
+          parse_multi_vagrant_up(result.stdout, update_specs)
+        end
+      end
+    end
+
+    def parse_vagrant_up(output, machine_spec)
+      # Grab forwarded port info
+      machine_spec.location['forwarded_ports'] = {}
+      in_forwarding_ports = false
+      output.lines.each do |line|
+        if in_forwarding_ports
+          if line =~ /-- (\d+) => (\d+)/
+            machine_spec.location['forwarded_ports'][$1] = $2
+          else
+            in_forwarding_ports = false
+          end
+        elsif line =~ /Forwarding ports...$/
+          in_forwarding_ports = true
+        end
+      end
+    end
+
+    def parse_multi_vagrant_up(output, all_machine_specs)
+      # Grab forwarded port info
+      in_forwarding_ports = {}
+      all_machine_specs.each_pair do |key, spec|
+        spec.location['forwarded_ports'] = {}
+        in_forwarding_ports[key] = false
+      end
+      output.lines.each do |line|
+        /^\[(.*?)\]/.match(line)
+        node_name = $1
+        if in_forwarding_ports[node_name]
+          if line =~ /-- (\d+) => (\d+)/
+            spec = all_machine_specs[node_name]
+            spec.location['forwarded_ports'][$1] = $2
+          else
+            in_forwarding_ports[node_name] = false
+          end
+        elsif line =~ /Forwarding ports...$/
+          in_forwarding_ports[node_name] = true
+        end
+      end
+    end
+
+    def machine_for(machine_spec, machine_options)
+      if machine_spec.location['vm.guest'].to_s == 'windows'
+        ChefMetal::Machine::WindowsMachine.new(machine_spec, transport_for(machine_spec),
+          convergence_strategy_for(machine_spec, machine_options))
+      else
+        ChefMetal::Machine::UnixMachine.new(machine_spec, transport_for(machine_spec),
+          convergence_strategy_for(machine_spec, machine_options))
+      end
+    end
+
+    def convergence_strategy_for(machine_spec, machine_options)
+      if machine_spec.location['vm.guest'].to_s == 'windows'
+        @windows_convergence_strategy ||= begin
+          ChefMetal::ConvergenceStrategy::InstallMsi.
+                                              new(machine_options[:convergence_options], config)
+        end
+      else
+        @unix_convergence_strategy ||= begin
+          ChefMetal::ConvergenceStrategy::InstallCached.
+                                           new(machine_options[:convergence_options], config)
+        end
+      end
+    end
+
+    def transport_for(machine_spec)
+      if machine_spec.location['vm.guest'].to_s == 'windows'
+        create_winrm_transport(machine_spec)
+      else
+        create_ssh_transport(machine_spec)
+      end
+    end
+
+    def vagrant_status(name)
+      status_output = shell_out("vagrant status #{name}", :cwd => cluster_path).stdout
+      if status_output =~ /^#{name}\s+([^\n]+)\s+\(([^\n]+)\)$/m
+        $1
+      else
+        'not created'
+      end
+    end
+
+    def create_winrm_transport(machine_spec)
+      forwarded_ports = machine_spec.location['forwarded_ports']
+
+      # TODO IPv6 loopback?  What do we do for that?
+      hostname = machine_spec.location['winrm.host'] || '127.0.0.1'
+      port = machine_spec.location['winrm.port'] || 5985
+      port = forwarded_ports[port] if forwarded_ports[port]
+      endpoint = "http://#{hostname}:#{port}/wsman"
+      type = :plaintext
+      options = {
+        :user => machine_spec.location['winrm.username'] || 'vagrant',
+        :pass => machine_spec.location['winrm.password'] || 'vagrant',
+        :disable_sspi => true
+      }
+
+      ChefMetal::Transport::WinRM.new(endpoint, type, options)
+    end
+
+    def create_ssh_transport(machine_spec)
+      vagrant_ssh_config = vagrant_ssh_config_for(machine_spec)
+      hostname = vagrant_ssh_config['HostName']
+      username = vagrant_ssh_config['User']
+      ssh_options = {
+        :port => vagrant_ssh_config['Port'],
+        :auth_methods => ['publickey'],
+        :user_known_hosts_file => vagrant_ssh_config['UserKnownHostsFile'],
+        :paranoid => yes_or_no(vagrant_ssh_config['StrictHostKeyChecking']),
+        :keys => [ strip_quotes(vagrant_ssh_config['IdentityFile']) ],
+        :keys_only => yes_or_no(vagrant_ssh_config['IdentitiesOnly'])
+      }
+      ssh_options[:auth_methods] = %w(password) if yes_or_no(vagrant_ssh_config['PasswordAuthentication'])
+      options = {
+        :prefix => 'sudo '
+      }
+      ChefMetal::Transport::SSH.new(hostname, username, ssh_options, options, config)
+    end
+
+    def vagrant_ssh_config_for(machine_spec)
+      vagrant_ssh_config = {}
+      result = shell_out("vagrant ssh-config #{machine_spec.location['vm_name']}",
+        :cwd => cluster_path)
+      result.stdout.lines.inject({}) do |result, line|
+        line =~ /^\s*(\S+)\s+(.+)/
+        vagrant_ssh_config[$1] = $2
+      end
+      vagrant_ssh_config
+    end
+
+    def yes_or_no(str)
+      case str
+      when 'yes'
+        true
+      else
+        false
+      end
+    end
+
+    def strip_quotes(str)
+      if str[0] == '"' && str[-1] == '"' && str.size >= 2
+        str[1..-2]
+      else
+        str
+      end
+    end
+  end
+end

data/lib/chef_metal_vagrant/version.rb

@@ -1,3 +1,3 @@
 module ChefMetalVagrant
-  VERSION = '0.3.1'
+  VERSION = '0.4.beta'
 end

data/lib/chef_metal_vagrant.rb

@@ -3,29 +3,31 @@ require 'chef/resource/vagrant_cluster'
 require 'chef/provider/vagrant_cluster'
 require 'chef/resource/vagrant_box'
 require 'chef/provider/vagrant_box'
-require 'chef_metal_vagrant/vagrant_provisioner'
+require 'chef_metal_vagrant/vagrant_driver'
 
 module ChefMetalVagrant
   def self.with_vagrant_box(run_context, box_name, vagrant_options = {}, &block)
     if box_name.is_a?(Chef::Resource::VagrantBox)
-      new_options = { 'vagrant_options' => { 'vm.box' => box_name.name } }
-      new_options['vagrant_options']['vm.box_url'] = box_name.url if box_name.url
+      new_options = { :vagrant_options => { 'vm.box' => box_name.name } }
+      new_options[:vagrant_options]['vm.box_url'] = box_name.url if box_name.url
     else
-      new_options = { 'vagrant_options' => { 'vm.box' => box_name } }
+      new_options = { :vagrant_options => { 'vm.box' => box_name } }
     end
 
-    run_context.chef_metal.add_provisioner_options(new_options, &block)
+    run_context.chef_metal.add_machine_options(new_options, &block)
   end
 end
 
 class Chef
-  class Recipe
-    def with_vagrant_cluster(cluster_path, &block)
-      with_provisioner(ChefMetalVagrant::VagrantProvisioner.new(cluster_path), &block)
-    end
+  module DSL
+    module Recipe
+      def with_vagrant_cluster(cluster_path, &block)
+        with_driver("vagrant:#{cluster_path}", &block)
+      end
 
-    def with_vagrant_box(box_name, vagrant_options = {}, &block)
-      ChefMetalVagrant.with_vagrant_box(run_context, box_name, vagrant_options, &block)
+      def with_vagrant_box(box_name, vagrant_options = {}, &block)
+        ChefMetalVagrant.with_vagrant_box(run_context, box_name, vagrant_options, &block)
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal-vagrant
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.beta
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-02 00:00:00.000000000 Z
+date: 2014-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -52,7 +52,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Provisioner for creating Vagrant instances in Chef Metal.
+description: Driver for creating Vagrant instances in Chef Metal.
 email: jkeiser@getchef.com
 executables: []
 extensions: []
@@ -67,8 +67,8 @@ files:
 - lib/chef/provider/vagrant_cluster.rb
 - lib/chef/resource/vagrant_box.rb
 - lib/chef/resource/vagrant_cluster.rb
-- lib/chef_metal/provisioner_init/vagrant_cluster_init.rb
-- lib/chef_metal_vagrant/vagrant_provisioner.rb
+- lib/chef_metal/driver_init/vagrant.rb
+- lib/chef_metal_vagrant/vagrant_driver.rb
 - lib/chef_metal_vagrant/version.rb
 - lib/chef_metal_vagrant.rb
 homepage: https://github.com/opscode/chef-metal-fog
@@ -85,14 +85,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: Provisioner for creating Vagrant instances in Chef Metal.
+summary: Driver for creating Vagrant instances in Chef Metal.
 test_files: []
 has_rdoc: 

data/lib/chef_metal/provisioner_init/vagrant_cluster_init.rb

@@ -1,4 +0,0 @@
-require 'chef_metal_vagrant/vagrant_provisioner'
-
-ChefMetal.add_registered_provisioner_class("vagrant_cluster",
-  ChefMetalVagrant::VagrantProvisioner)

data/lib/chef_metal_vagrant/vagrant_provisioner.rb

@@ -1,361 +0,0 @@
-require 'chef/mixin/shell_out'
-require 'chef_metal/provisioner'
-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/winrm'
-require 'chef_metal/transport/ssh'
-
-module ChefMetalVagrant
-  # Provisions machines in vagrant.
-  class VagrantProvisioner < ChefMetal::Provisioner
-
-    include Chef::Mixin::ShellOut
-
-    # Create a new vagrant provisioner.
-    #
-    # ## Parameters
-    # cluster_path - path to the directory containing the vagrant files, which
-    #                should have been created with the vagrant_cluster resource.
-    def initialize(cluster_path)
-      @cluster_path = cluster_path
-    end
-
-    attr_reader :cluster_path
-
-    # Inflate a provisioner from node 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 - node to inflate the provisioner for
-    #
-    # returns a VagrantProvisioner
-    def self.inflate(node)
-      node_url = node['normal']['provisioner_output']['provisioner_url']
-      cluster_path = node_url.split(':', 2)[1].sub(/^\/\//, "")
-      self.new(cluster_path)
-    end
-
-    # Acquire a machine, generally by provisioning it.  Returns a Machine
-    # object pointing at the machine, allowing useful actions like setup,
-    # converge, execute, file and directory.  The Machine object will have a
-    # "node" property which must be saved to the server (if it is any
-    # different from the original node object).
-    #
-    # ## Parameters
-    # action_handler - the action_handler object that is calling this method; this
-    #        is generally a action_handler, but could be anything that can support the
-    #        ChefMetal::ActionHandler interface (i.e., in the case of the test
-    #        kitchen metal driver for acquiring and destroying VMs; see the base
-    #        class for what needs providing).
-    # node - node object (deserialized json) representing this machine.  If
-    #        the node has a provisioner_options hash in it, these will be used
-    #        instead of options provided by the provisioner.  TODO compare and
-    #        fail if different?
-    #        node will have node['normal']['provisioner_options'] in it with any options.
-    #        It is a hash with this format (all keys are strings):
-    #
-    #           -- provisioner_url: vagrant:<cluster_path>
-    #           -- vagrant_options: hash of properties of the "config"
-    #              object, i.e. "vm.box" => "ubuntu12" and "vm.box_url"
-    #           -- vagrant_config: string containing other vagrant config.
-    #              Should assume the variable "config" represents machine config.
-    #              Will be written verbatim into the vm's Vagrantfile.
-    #           -- transport_options: hash of options specifying the transport.
-    #                :type => :ssh
-    #                :type => :winrm
-    #                If not specified, ssh is used unless vm.guest is :windows.  If that is
-    #                the case, the windows options are used and the port forward for 5985
-    #                is detected.
-    #           -- up_timeout: maximum time, in seconds, to wait for vagrant
-    #              to bring up the machine.  Defaults to 10 minutes.
-    #           -- chef_client_timeout: maximum time, in seconds, to wait for chef-client
-    #              to complete.  0 or nil for no timeout.  Defaults to 2 hours.
-    #
-    #        node['normal']['provisioner_output'] will be populated with information
-    #        about the created machine.  For vagrant, it is a hash with this
-    #        format:
-    #
-    #           -- provisioner_url: vagrant_cluster://<current_node>/<cluster_path>
-    #           -- vm_name: name of vagrant vm created
-    #           -- vm_file_path: path to machine-specific vagrant config file
-    #              on disk
-    #           -- forwarded_ports: hash with key as guest_port => host_port
-    #
-    def acquire_machine(action_handler, node)
-      # Set up the provisioner output
-      provisioner_options = node['normal']['provisioner_options']
-      vm_name = node['name']
-      old_provisioner_output = node['normal']['provisioner_output']
-      node['normal']['provisioner_output'] = provisioner_output = {
-        'provisioner_url' => provisioner_url(vm_name),
-        'vm_name' => vm_name,
-        'vm_file_path' => File.join(cluster_path, "#{vm_name}.vm")
-      }
-      # Preserve existing forwarded ports
-      provisioner_output['forwarded_ports'] = old_provisioner_output['forwarded_ports'] if old_provisioner_output
-
-      # TODO compare new options to existing and fail if we cannot change it
-      # over (perhaps introduce a boolean that will force a delete and recreate
-      # in such a case)
-
-      #
-      # This is where the work gets done:
-      # Create the .vm file, start the vm, and return the Machine
-      #
-      vm_file_updated = create_vm_file(action_handler, vm_name, provisioner_output['vm_file_path'], provisioner_options)
-      start_machine(action_handler, vm_name, vm_file_updated, provisioner_output, provisioner_options['up_timeout'])
-      machine_for(node)
-    end
-
-    # Connect to machine without acquiring it
-    def connect_to_machine(node)
-      machine_for(node)
-    end
-
-    def delete_machine(action_handler, node)
-      if node['normal'] && node['normal']['provisioner_output']
-        provisioner_output = node['normal']['provisioner_output']
-      else
-        provisioner_output = {}
-      end
-      vm_name = provisioner_output['vm_name'] || node['name']
-      current_status = vagrant_status(vm_name)
-      if current_status != 'not created'
-        action_handler.perform_action "run vagrant destroy -f #{vm_name} (status was '#{current_status}')" do
-          result = shell_out("vagrant destroy -f #{vm_name}", :cwd => cluster_path)
-          if result.exitstatus != 0
-            raise "vagrant destroy failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
-          end
-        end
-      end
-
-      convergence_strategy_for(node).cleanup_convergence(action_handler, node)
-
-      vm_file_path = provisioner_output['vm_file_path'] || File.join(cluster_path, "#{vm_name}.vm")
-      ChefMetal.inline_resource(action_handler) do
-        file vm_file_path do
-          action :delete
-        end
-      end
-    end
-
-    def stop_machine(action_handler, node)
-      if node['normal'] && node['normal']['provisioner_output']
-        provisioner_output = node['normal']['provisioner_output']
-      else
-        provisioner_output = {}
-      end
-      vm_name = provisioner_output['vm_name'] || node['name']
-      current_status = vagrant_status(vm_name)
-      if current_status == 'running'
-        action_handler.perform_action "run vagrant halt #{vm_name} (status was '#{current_status}')" do
-          result = shell_out("vagrant halt #{vm_name}", :cwd => cluster_path)
-          if result.exitstatus != 0
-            raise "vagrant halt failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
-          end
-        end
-      end
-    end
-
-
-    # Used by vagrant_cluster and machine to get the string used to configure vagrant
-    def self.vagrant_config_string(vagrant_config, variable, line_prefix)
-      hostname = name.gsub(/[^A-Za-z0-9\-]/, '-')
-
-      result = ''
-      vagrant_config.each_pair do |key, value|
-        result += "#{line_prefix}#{variable}.#{key} = #{value.inspect}\n"
-      end
-      result
-    end
-
-    protected
-
-    def provisioner_url(vm_name)
-      "vagrant_cluster://#{vm_name}#{cluster_path}"
-    end
-
-    def create_vm_file(action_handler, vm_name, vm_file_path, provisioner_options)
-      # Determine contents of vm file
-      vm_file_content = "Vagrant.configure('2') do |outer_config|\n"
-      vm_file_content << "  outer_config.vm.define #{vm_name.inspect} do |config|\n"
-      merged_vagrant_options = { 'vm.hostname' => vm_name }
-      merged_vagrant_options.merge!(provisioner_options['vagrant_options']) if provisioner_options['vagrant_options']
-      merged_vagrant_options.each_pair do |key, value|
-        vm_file_content << "    config.#{key} = #{value.inspect}\n"
-      end
-      vm_file_content << provisioner_options['vagrant_config'] if provisioner_options['vagrant_config']
-      vm_file_content << "  end\nend\n"
-
-      # Set up vagrant file
-      ChefMetal.inline_resource(action_handler) do
-        file vm_file_path do
-          content vm_file_content
-          action :create
-        end
-      end
-    end
-
-    def start_machine(action_handler, vm_name, vm_file_updated, provisioner_output, up_timeout)
-      # Check current status of vm
-      current_status = vagrant_status(vm_name)
-      up_timeout ||= 10*60
-
-      if current_status != 'running'
-        # Run vagrant up if vm is not running
-        action_handler.perform_action "run vagrant up #{vm_name} (status was '#{current_status}')" do
-          result = shell_out("vagrant up #{vm_name}", :cwd => cluster_path, :timeout => up_timeout)
-          if result.exitstatus != 0
-            raise "vagrant up #{vm_name} failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
-          end
-          parse_vagrant_up(result.stdout, provisioner_output)
-        end
-      elsif vm_file_updated
-        # Run vagrant reload if vm is running and vm file changed
-        action_handler.perform_action "run vagrant reload #{vm_name}" do
-          result = shell_out("vagrant reload #{vm_name}", :cwd => cluster_path, :timeout => up_timeout)
-          if result.exitstatus != 0
-            raise "vagrant reload #{vm_name} failed!\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
-          end
-          parse_vagrant_up(result.stdout, provisioner_output)
-        end
-      end
-    end
-
-    def parse_vagrant_up(output, provisioner_output)
-      # Grab forwarded port info
-      provisioner_output['forwarded_ports'] = {}
-      in_forwarding_ports = false
-      output.lines.each do |line|
-        if in_forwarding_ports
-          if line =~ /-- (\d+) => (\d+)/
-            provisioner_output['forwarded_ports'][$1] = $2
-          else
-            in_forwarding_ports = false
-          end
-        elsif line =~ /Forwarding ports...$/
-          in_forwarding_ports = true
-        end
-      end
-    end
-
-    def machine_for(node)
-      if vagrant_option(node, 'vm.guest').to_s == 'windows'
-        ChefMetal::Machine::WindowsMachine.new(node, transport_for(node), convergence_strategy_for(node))
-      else
-        ChefMetal::Machine::UnixMachine.new(node, transport_for(node), convergence_strategy_for(node))
-      end
-    end
-
-    def convergence_strategy_for(node)
-      if vagrant_option(node, 'vm.guest').to_s == 'windows'
-        @windows_convergence_strategy ||= begin
-          options = {}
-          provisioner_options = node['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['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 transport_for(node)
-      if vagrant_option(node, 'vm.guest').to_s == 'windows'
-        create_winrm_transport(node)
-      else
-        create_ssh_transport(node)
-      end
-    end
-
-    def vagrant_option(node, option)
-      if node['normal']['provisioner_options'] &&
-         node['normal']['provisioner_options']['vagrant_options']
-        node['normal']['provisioner_options']['vagrant_options'][option]
-      else
-        nil
-      end
-    end
-
-    def vagrant_status(name)
-      status_output = shell_out("vagrant status #{name}", :cwd => cluster_path).stdout
-      if status_output =~ /^#{name}\s+([^\n]+)\s+\(([^\n]+)\)$/m
-        $1
-      else
-        'not created'
-      end
-    end
-
-    def create_winrm_transport(node)
-      provisioner_output = node['default']['provisioner_output'] || {}
-      forwarded_ports = provisioner_output['forwarded_ports'] || {}
-
-      # TODO IPv6 loopback?  What do we do for that?
-      hostname = vagrant_option(node, 'winrm.host') || '127.0.0.1'
-      port = vagrant_option(node, 'winrm.port') || forwarded_ports[5985] || 5985
-      endpoint = "http://#{hostname}:#{port}/wsman"
-      type = :plaintext
-      options = {
-        :user => vagrant_option(node, 'winrm.username') || 'vagrant',
-        :pass => vagrant_option(node, 'winrm.password') || 'vagrant',
-        :disable_sspi => true
-      }
-
-      ChefMetal::Transport::WinRM.new(endpoint, type, options)
-    end
-
-    def create_ssh_transport(node)
-      vagrant_ssh_config = vagrant_ssh_config_for(node)
-      hostname = vagrant_ssh_config['HostName']
-      username = vagrant_ssh_config['User']
-      ssh_options = {
-        :port => vagrant_ssh_config['Port'],
-        :auth_methods => ['publickey'],
-        :user_known_hosts_file => vagrant_ssh_config['UserKnownHostsFile'],
-        :paranoid => yes_or_no(vagrant_ssh_config['StrictHostKeyChecking']),
-        :keys => [ strip_quotes(vagrant_ssh_config['IdentityFile']) ],
-        :keys_only => yes_or_no(vagrant_ssh_config['IdentitiesOnly'])
-      }
-      ssh_options[:auth_methods] = %w(password) if yes_or_no(vagrant_ssh_config['PasswordAuthentication'])
-      options = {
-        :prefix => 'sudo '
-      }
-      ChefMetal::Transport::SSH.new(hostname, username, ssh_options, options)
-    end
-
-    def vagrant_ssh_config_for(node)
-      vagrant_ssh_config = {}
-      result = shell_out("vagrant ssh-config #{node['normal']['provisioner_output']['vm_name']}", :cwd => cluster_path)
-      result.stdout.lines.inject({}) do |result, line|
-        line =~ /^\s*(\S+)\s+(.+)/
-        vagrant_ssh_config[$1] = $2
-      end
-      vagrant_ssh_config
-    end
-
-    def yes_or_no(str)
-      case str
-      when 'yes'
-        true
-      else
-        false
-      end
-    end
-
-    def strip_quotes(str)
-      if str[0] == '"' && str[-1] == '"' && str.size >= 2
-        str[1..-2]
-      else
-        str
-      end
-    end
-  end
-end