vagrant-windows 1.5.1 → 1.6.0.pre.1

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
   - 1.9.3
-  - 1.9.2
   - 2.0.0
+  - 2.1.0

data/README.md

@@ -3,7 +3,7 @@
 [![Code Climate](https://codeclimate.com/github/WinRb/vagrant-windows.png)](https://codeclimate.com/github/WinRb/vagrant-windows)
 [![Gem Version](https://badge.fury.io/rb/vagrant-windows.png)](http://badge.fury.io/rb/vagrant-windows)
 
-Use Windows guests with Vagrant
+This [Vagrant](http://www.vagrantup.com/) plugin allows you to standup Windows guests using [WinRM](http://msdn.microsoft.com/en-us/library/aa384426\(v=vs.85\).aspx) instead of SSH. Additionally this plugin makes it easier to provision with Chef, Puppet, and the shell (PowerShell) on Windows guests.
 
 ## Getting Started
 1. Install the vagrant-windows plugin.

data/lib/vagrant-windows/monkey_patches/plugins/provisioners/chef/provisioner/chef_client.rb

@@ -1 +1,74 @@
-# TODO: support Chef client
+require "#{Vagrant::source_root}/plugins/provisioners/chef/provisioner/chef_client"
+require_relative '../../../../../helper'
+require_relative '../../../../../windows_machine'
+require_relative '../../../../../provisioners/chef_command_builder'
+
+module VagrantPlugins
+  module Chef
+    module Provisioner
+      class ChefClient < Base
+
+        include VagrantWindows::Helper
+
+        def initialize(machine, config)
+          super
+          @windows_machine = VagrantWindows::WindowsMachine.new(machine)
+          @logger = Log4r::Logger.new("vagrant::provisioners::chef_client")
+        end
+
+        provision_on_linux = instance_method(:provision)
+        run_chef_client_on_linux = instance_method(:run_chef_client)
+
+        define_method(:run_chef_client) do
+          @windows_machine.is_windows? ? run_chef_client_on_windows() : run_chef_client_on_linux.bind(self).()
+        end
+        
+        define_method(:provision) do
+          wait_if_rebooting(@windows_machine) if @windows_machine.is_windows?
+          provision_on_linux.bind(self).()
+        end
+        
+        def run_chef_client_on_windows
+          if @config.run_list && @config.run_list.empty?
+            @machine.ui.warn(I18n.t("vagrant.chef_run_list_empty"))
+          end
+
+          #################### START - monkey patched code ####################
+          command_builder = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
+            @windows_machine, @config, :client)
+          
+          command_builder.prepare_for_chef_run()
+          command = command_builder.run_chef_command()
+          ###################### END - monkey patched code ####################
+
+          @config.attempts.times do |attempt|
+            if attempt == 0
+              @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_client")
+            else
+              @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_client_again")
+            end
+
+            #################### START - monkey patched code ####################
+            @windows_machine.reinitialize_network_shares()
+            ###################### END - monkey patched code ####################
+
+            exit_status = @machine.communicate.execute(command, :error_check => false) do |type, data|
+              # Output the data with the proper color based on the stream.
+              color = type == :stdout ? :green : :red
+
+              @machine.env.ui.info(
+                data, :color => color, :new_line => false, :prefix => false)
+            end
+
+            # There is no need to run Chef again if it converges
+            return if exit_status == 0
+          end
+
+          # If we reached this point then Chef never converged! Error.
+          raise ChefError, :no_convergence
+        end
+        
+      end # ChefSolo class
+    end
+  end
+end

data/lib/vagrant-windows/monkey_patches/plugins/provisioners/chef/provisioner/chef_solo.rb

@@ -1,46 +1,43 @@
-require 'tempfile'
 require "#{Vagrant::source_root}/plugins/provisioners/chef/provisioner/chef_solo"
 require_relative '../../../../../helper'
 require_relative '../../../../../windows_machine'
+require_relative '../../../../../provisioners/chef_command_builder'
 
 module VagrantPlugins
   module Chef
     module Provisioner
       class ChefSolo < Base
-        
+
         include VagrantWindows::Helper
+        
+        def initialize(machine, config)
+          super
+          @windows_machine = VagrantWindows::WindowsMachine.new(machine)
+          @logger = Log4r::Logger.new("vagrant::provisioners::chef_solo")
+        end
 
         provision_on_linux = instance_method(:provision)
         run_chef_solo_on_linux = instance_method(:run_chef_solo)
 
         # This patch is needed until Vagrant supports chef on Windows guests
         define_method(:run_chef_solo) do
-          is_windows? ? run_chef_solo_on_windows() : run_chef_solo_on_linux.bind(self).()
+          @windows_machine.is_windows? ? run_chef_solo_on_windows() : run_chef_solo_on_linux.bind(self).()
         end
         
         define_method(:provision) do
-          windows_machine = VagrantWindows::WindowsMachine.new(@machine)
-          wait_if_rebooting(windows_machine) if is_windows?
+          wait_if_rebooting(@windows_machine) if @windows_machine.is_windows?
           provision_on_linux.bind(self).()
         end
         
         def run_chef_solo_on_windows
-          # create cheftaskrun.ps1 that the scheduled task will invoke when run
-          render_file_and_upload("cheftaskrun.ps1", chef_script_options[:chef_task_run_ps1], :options => chef_script_options)
-
-          # create cheftask.xml that the scheduled task will be created with
-          render_file_and_upload("cheftask.xml", chef_script_options[:chef_task_xml], :options => chef_script_options)
-
-          # create cheftask.ps1 that will immediately invoke the scheduled task and wait for completion
-          render_file_and_upload("cheftask.ps1", chef_script_options[:chef_task_ps1], :options => chef_script_options)
           
-          command = <<-EOH
-          $old = Get-ExecutionPolicy;
-          Set-ExecutionPolicy Unrestricted -force;
-          #{chef_script_options[:chef_task_ps1]};
-          Set-ExecutionPolicy $old -force
-          exit $LASTEXITCODE
-          EOH
+          #################### START - monkey patched code ####################
+          command_builder = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
+            @windows_machine, @config, :solo)
+          
+          command_builder.prepare_for_chef_run()
+          command = command_builder.run_chef_command()
+          ###################### END - monkey patched code ####################
 
           @config.attempts.times do |attempt|
             if attempt == 0
@@ -49,9 +46,9 @@ module VagrantPlugins
               @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_solo_again")
             end
             
-            # This re-establishes our symbolic links if they were created between now and a reboot
-            # Fixes issue #119
-            @machine.communicate.execute('& net use a-non-existant-share', :error_check => false)
+            #################### START - monkey patched code ####################
+            @windows_machine.reinitialize_network_shares()
+            ###################### END - monkey patched code ####################
 
             exit_status = @machine.communicate.execute(command, :error_check => false) do |type, data|
               # Output the data with the proper color based on the stream.
@@ -69,49 +66,6 @@ module VagrantPlugins
           raise ChefError, :no_convergence
         end
         
-        def render_file_and_upload(script_name, dest_file, options)
-          script_contents = VagrantWindows.load_script_template(script_name, options)
-
-          # render cheftaskrun.ps1 to local temp file
-          script_local = Tempfile.new(script_name)
-          IO.write(script_local, script_contents)
-          
-          # upload cheftaskrun.ps1 file
-          @machine.communicate.upload(script_local, dest_file)
-        end
-        
-        def chef_script_options
-          if @chef_script_options.nil?
-            command_env = @config.binary_env ? "#{@config.binary_env} " : ""
-            command_args = @config.arguments ? " #{@config.arguments}" : ""
-            chef_solo_path = win_friendly_path(File.join(@config.provisioning_path, 'solo.rb'))
-            chef_dna_path = win_friendly_path(File.join(@config.provisioning_path, 'dna.json'))
-          
-            chef_arguments = "-c #{chef_solo_path} "
-            chef_arguments << "-j #{chef_dna_path} "
-            chef_arguments << "#{command_args}"
-          
-            @chef_script_options = {
-              :user => @machine.config.winrm.username,
-              :pass => @machine.config.winrm.password,
-              :chef_arguments => chef_arguments,
-              :chef_task_xml => win_friendly_path("#{@config.provisioning_path}/cheftask.xml"),
-              :chef_task_running => win_friendly_path("#{@config.provisioning_path}/cheftask.running"),
-              :chef_task_exitcode => win_friendly_path("#{@config.provisioning_path}/cheftask.exitcode"),
-              :chef_task_ps1 => win_friendly_path("#{@config.provisioning_path}/cheftask.ps1"),
-              :chef_task_run_ps1 => win_friendly_path("#{@config.provisioning_path}/cheftaskrun.ps1"),
-              :chef_stdout_log => win_friendly_path("#{@config.provisioning_path}/chef-solo.log"),
-              :chef_stderr_log => win_friendly_path("#{@config.provisioning_path}/chef-solo.err.log"),
-              :chef_binary_path => win_friendly_path("#{command_env}#{chef_binary_path("chef-solo")}")
-            }
-          end
-          @chef_script_options
-        end
-        
-        def is_windows?
-          VagrantWindows::WindowsMachine.is_windows?(@machine)
-        end
-        
       end # ChefSolo class
     end
   end

data/lib/vagrant-windows/provisioners/chef_command_builder.rb

@@ -0,0 +1,105 @@
+require 'tempfile'
+require_relative '../helper'
+require_relative '../windows_machine'
+
+module VagrantWindows
+  module Provisioners
+
+    # Builds scripts and ultimately the command to execute Chef solo or Chef client
+    # on Windows guests using a scheduled task.
+    class ChefCommandBuilder
+      
+      include VagrantWindows::Helper
+
+      def initialize(windows_machine, chef_config, client_type)
+        @windows_machine = windows_machine
+        @config = chef_config
+
+        if client_type != :solo && client_type != :client
+          raise 'Invalid client_type, expected solo or client'
+        end
+
+        @client_type = client_type
+      end
+
+      def prepare_for_chef_run()
+        options = create_chef_options()
+
+        # create cheftaskrun.ps1 that the scheduled task will invoke when run
+        render_file_and_upload('cheftaskrun.ps1', options[:chef_task_run_ps1],
+          :options => options)
+
+        # create cheftask.xml that the scheduled task will be created with
+        render_file_and_upload('cheftask.xml', options[:chef_task_xml],
+          :options => options)
+
+        # create cheftask.ps1 that will immediately invoke the scheduled task and wait for completion
+        render_file_and_upload('cheftask.ps1', options[:chef_task_ps1],
+          :options => options)
+      end
+
+      def run_chef_command()
+        return <<-EOH
+        $old = Get-ExecutionPolicy;
+        Set-ExecutionPolicy Unrestricted -force;
+        #{chef_task_ps1_path};
+        Set-ExecutionPolicy $old -force
+        EOH
+      end
+
+
+
+      def render_file_and_upload(script_name, dest_file, options)
+        # render the script file to a local temp file and then upload
+        script_local = Tempfile.new(script_name)
+        IO.write(script_local, VagrantWindows.load_script_template(script_name, options))
+        @windows_machine.winrmshell.upload(script_local, dest_file)
+      end
+      
+      def create_chef_options
+        command_env = @config.binary_env ? "#{@config.binary_env} " : ''
+        return {
+          :user => @windows_machine.winrm_config.username,
+          :pass => @windows_machine.winrm_config.password,
+          :chef_arguments => create_chef_arguments(),
+          :chef_task_xml => provisioning_path('cheftask.xml'),
+          :chef_task_running => provisioning_path('cheftask.running'),
+          :chef_task_exitcode => provisioning_path('cheftask.exitcode'),
+          :chef_task_ps1 => chef_task_ps1_path(),
+          :chef_task_run_ps1 => provisioning_path('cheftaskrun.ps1'),
+          :chef_stdout_log => provisioning_path("chef-#{@client_type}.log"),
+          :chef_stderr_log => provisioning_path("chef-#{@client_type}.err.log"),
+          :chef_binary_path => win_friendly_path("#{command_env}#{chef_binary_path}")
+        }
+      end
+
+      def create_chef_arguments()
+        command_args = @config.arguments ? @config.arguments : ''
+        chef_path = provisioning_path("#{@client_type}.rb")
+        chef_dna_path = provisioning_path('dna.json')
+
+        chef_arguments = "-c #{chef_path}"
+        chef_arguments << " -j #{chef_dna_path}"
+        chef_arguments << " #{command_args}"
+        chef_arguments.strip
+      end
+
+      def chef_task_ps1_path()
+        provisioning_path('cheftask.ps1')
+      end
+
+      # Returns the path to the Chef binary, taking into account the
+      # `binary_path` configuration option.
+      def chef_binary_path()
+        binary = "chef-#{@client_type}"
+        return binary if !@config.binary_path
+        return win_friendly_path(File.join(@config.binary_path, binary))
+      end
+
+      def provisioning_path(file_name)
+        win_friendly_path("#{@config.provisioning_path}/#{file_name}")
+      end
+
+    end
+  end
+end

data/lib/vagrant-windows/version.rb

@@ -1,3 +1,3 @@
 module VagrantWindows
-  VERSION = "1.5.1"
+  VERSION = "1.6.0.pre.1"
 end

data/lib/vagrant-windows/windows_machine.rb

@@ -18,6 +18,13 @@ module VagrantWindows
       @machine = machine
       @logger = Log4r::Logger.new("vagrant_windows::windows_machine")
     end
+
+    # Returns true if this Vagrant machine is a Windows guest, otherwise false.
+    #
+    # @return [Boolean]
+    def is_windows?()
+      WindowsMachine.is_windows?(@machine)
+    end
     
     # Checks to see if the machine is using VMWare Fusion or Workstation.
     #
@@ -55,6 +62,12 @@ module VagrantWindows
       @machine.communicate.winrmshell
     end
 
+    # Re-establishes our symbolic links if they were created between now and a reboot
+    # Fixes issue #119
+    def reinitialize_network_shares()
+      winrmshell.powershell('& net use a-non-existant-share')
+    end
+
     # Reads the machine's MAC addresses keyed by interface index.
     # {1=>"0800273FAC5A", 2=>"08002757E68A"}
     #

data/spec/vagrant-windows/chef_command_builder_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe VagrantWindows::Provisioners::ChefCommandBuilder, :unit => true do
+
+  before(:each) do
+    @winrm_config = stub()
+    @winrm_config.stubs(:username).returns('vagrant')
+    @winrm_config.stubs(:password).returns('secret')
+
+    @windows_machine = stub()
+    @windows_machine.stubs(:winrm_config).returns(@winrm_config)
+
+    @chef_config = stub()
+    @chef_config.stubs(:provisioning_path).returns('/tmp/vagrant-chef-1')
+    @chef_config.stubs(:arguments).returns(nil)
+    @chef_config.stubs(:binary_env).returns(nil)
+    @chef_config.stubs(:binary_path).returns(nil)
+
+    @chef_cmd_builder = VagrantWindows::Provisioners::ChefCommandBuilder.new(
+      @windows_machine, @chef_config, :client)
+  end
+
+  describe 'initialize' do
+    it 'should raise when chef type is not client or solo' do
+      expect { VagrantWindows::Provisioners::ChefCommandBuilder.new(@windows_machine, @chef_config, :zero) }.to raise_error
+    end
+  end
+
+  describe 'provisioning_path' do
+    it 'should be windows friendly' do
+      @chef_cmd_builder.provisioning_path('script.ps1').should eql 'c:\tmp\vagrant-chef-1\script.ps1'
+    end
+  end
+
+  describe 'create_chef_arguments' do
+    it 'should include paths to client.rb and dna.json' do
+      expected = '-c c:\tmp\vagrant-chef-1\client.rb -j c:\tmp\vagrant-chef-1\dna.json'
+      @chef_cmd_builder.create_chef_arguments().should eql expected
+    end
+
+    it 'should include Chef arguments if specified' do
+      @chef_config.stubs(:arguments).returns('-l DEBUG')
+      expected = '-c c:\tmp\vagrant-chef-1\client.rb -j c:\tmp\vagrant-chef-1\dna.json -l DEBUG'
+      @chef_cmd_builder.create_chef_arguments().should eql expected
+    end
+  end
+
+  describe 'create_chef_options' do
+    it "should include winrm username and password" do
+      options = @chef_cmd_builder.create_chef_options()
+      options[:user].should eql 'vagrant'
+      options[:pass].should eql 'secret'
+    end
+
+    it 'should include paths to scripts' do
+      options = @chef_cmd_builder.create_chef_options()
+      options[:chef_task_xml].should eql 'c:\tmp\vagrant-chef-1\cheftask.xml'
+      options[:chef_task_ps1].should eql 'c:\tmp\vagrant-chef-1\cheftask.ps1'
+      options[:chef_task_run_ps1].should eql 'c:\tmp\vagrant-chef-1\cheftaskrun.ps1'
+    end
+
+    it 'should include paths to process flow files' do
+      options = @chef_cmd_builder.create_chef_options()
+      options[:chef_task_running].should eql 'c:\tmp\vagrant-chef-1\cheftask.running'
+      options[:chef_task_exitcode].should eql 'c:\tmp\vagrant-chef-1\cheftask.exitcode'
+    end
+
+    it 'should include paths to logs' do
+      options = @chef_cmd_builder.create_chef_options()
+      options[:chef_stdout_log].should eql 'c:\tmp\vagrant-chef-1\chef-client.log'
+      options[:chef_stderr_log].should eql 'c:\tmp\vagrant-chef-1\chef-client.err.log'
+    end
+
+    it 'should include path to chef binary' do
+      options = @chef_cmd_builder.create_chef_options()
+      options[:chef_binary_path].should eql 'chef-client'
+    end
+
+    it 'should include full path to chef binary when binary_path is set' do
+      @chef_config.stubs(:binary_path).returns('c:/opscode/chef/bin')
+      options = @chef_cmd_builder.create_chef_options()
+      options[:chef_binary_path].should eql 'c:\opscode\chef\bin\chef-client'
+    end
+
+  end
+
+  describe 'prepare_for_chef_run' do
+    it 'should upload cheftask scripts' do
+      winrmshell = double()
+      @windows_machine.stubs(:winrmshell).returns(winrmshell)
+
+      winrmshell.should_receive(:upload).with(anything(), 'c:\tmp\vagrant-chef-1\cheftaskrun.ps1')
+      winrmshell.should_receive(:upload).with(anything(), 'c:\tmp\vagrant-chef-1\cheftask.xml')
+      winrmshell.should_receive(:upload).with(anything(), 'c:\tmp\vagrant-chef-1\cheftask.ps1')
+
+      @chef_cmd_builder.prepare_for_chef_run()
+    end
+
+  end
+
+end

data/spec/vagrant-windows/windows_machine_spec.rb

@@ -37,6 +37,20 @@ describe VagrantWindows::WindowsMachine , :unit => true do
       expect(windows_machine.is_virtualbox?()).to be_false
     end
   end
+
+  describe "is_parallels?" do
+    it "should be true for parallels" do
+      machine = stub(:provider_name => :parallels)
+      windows_machine = VagrantWindows::WindowsMachine.new(machine)
+      expect(windows_machine.is_parallels?()).to be_true
+    end
+    
+    it "should be false for vmware_workstation" do
+      machine = stub(:provider_name => :vmware_workstation)
+      windows_machine = VagrantWindows::WindowsMachine.new(machine)
+      expect(windows_machine.is_parallels?()).to be_false
+    end
+  end
   
   describe "is_windows?" do
     it "should return true when config vm guest is windows" do
@@ -45,6 +59,14 @@ describe VagrantWindows::WindowsMachine , :unit => true do
       machine = stub(:config => config)
       expect(VagrantWindows::WindowsMachine.is_windows?(machine)).to be_true
     end
+
+    it "instance should return true when config vm guest is windows" do
+      vm = stub(:guest => :windows)
+      config = stub(:vm => vm)
+      machine = stub(:config => config)
+      windows_machine = VagrantWindows::WindowsMachine.new(machine)
+      expect(windows_machine.is_windows?()).to be_true
+    end
     
     it "should return false when config vm guest is not windows" do
       vm = stub(:guest => :ubuntu)
@@ -52,6 +74,14 @@ describe VagrantWindows::WindowsMachine , :unit => true do
       machine = stub(:config => config)
       expect(VagrantWindows::WindowsMachine.is_windows?(machine)).to be_false
     end
+
+    it "instance should return false when config vm guest is not windows" do
+      vm = stub(:guest => :fedora)
+      config = stub(:vm => vm)
+      machine = stub(:config => config)
+      windows_machine = VagrantWindows::WindowsMachine.new(machine)
+      expect(windows_machine.is_windows?()).to be_false
+    end
   end
   
   describe "read_forwarded_ports" do

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-windows
 version: !ruby/object:Gem::Version
-  version: 1.5.1
-  prerelease: 
+  version: 1.6.0.pre.1
+  prerelease: 6
 platform: ruby
 authors:
 - Paul Morton
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-08 00:00:00.000000000 Z
+date: 2014-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: winrm
@@ -142,6 +142,7 @@ files:
 - lib/vagrant-windows/monkey_patches/plugins/provisioners/puppet/provisioner/puppet_server.rb
 - lib/vagrant-windows/monkey_patches/plugins/provisioners/shell/provisioner.rb
 - lib/vagrant-windows/plugin.rb
+- lib/vagrant-windows/provisioners/chef_command_builder.rb
 - lib/vagrant-windows/scripts/cheftask.ps1.erb
 - lib/vagrant-windows/scripts/cheftask.xml.erb
 - lib/vagrant-windows/scripts/cheftaskrun.ps1.erb
@@ -158,6 +159,7 @@ files:
 - Rakefile
 - README.md
 - spec/spec_helper.rb
+- spec/vagrant-windows/chef_command_builder_spec.rb
 - spec/vagrant-windows/guestnetwork_spec.rb
 - spec/vagrant-windows/helper_spec.rb
 - spec/vagrant-windows/mount_shared_folder_spec.rb
@@ -185,16 +187,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4320786780650999420
+      hash: 1012872433486920288
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -4320786780650999420
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -204,6 +203,7 @@ summary: A small gem that adds windows guest support to vagrant, uses WinRM as t
   Communication Channel
 test_files:
 - spec/spec_helper.rb
+- spec/vagrant-windows/chef_command_builder_spec.rb
 - spec/vagrant-windows/guestnetwork_spec.rb
 - spec/vagrant-windows/helper_spec.rb
 - spec/vagrant-windows/mount_shared_folder_spec.rb