vagrant-windows 1.2.0 → 1.3.1

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

@@ -1,6 +1,7 @@
 require 'tempfile'
 require "#{Vagrant::source_root}/plugins/provisioners/chef/provisioner/chef_solo"
 require_relative '../../../../../helper'
+require_relative '../../../../../windows_machine'
 
 module VagrantPlugins
   module Chef
@@ -9,11 +10,18 @@ module VagrantPlugins
         
         include VagrantWindows::Helper
 
+        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).()
+          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?
+          provision_on_linux.bind(self).()
         end
         
         def run_chef_solo_on_windows
@@ -40,8 +48,12 @@ module VagrantPlugins
             else
               @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)
 
-            exit_status = @machine.communicate.execute(command) do |type, data|
+            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
 
@@ -94,10 +106,10 @@ module VagrantPlugins
             }
           end
           @chef_script_options
-        end        
+        end
         
-        def is_windows
-          @machine.config.vm.guest.eql? :windows
+        def is_windows?
+          VagrantWindows::WindowsMachine.is_windows?(@machine)
         end
         
       end # ChefSolo class

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

@@ -1,24 +1,40 @@
 require "#{Vagrant::source_root}/plugins/provisioners/puppet/provisioner/puppet"
+require_relative '../../../../../windows_machine'
+require_relative '../../../../../helper'
+require_relative '../../../../../errors'
 
 module VagrantPlugins
   module Puppet
     module Provisioner
       class Puppet < Vagrant.plugin("2", :provisioner)
         
+        include VagrantWindows::Helper
+
         # This patch is needed until Vagrant supports Puppet on Windows guests
+        provision_on_linux = instance_method(:provision)
         run_puppet_apply_on_linux = instance_method(:run_puppet_apply)
         configure_on_linux = instance_method(:configure)
-        
+
         define_method(:run_puppet_apply) do
-          is_windows ? run_puppet_apply_on_windows() : run_puppet_apply_on_linux.bind(self).()
+          is_windows? ? run_puppet_apply_on_windows() : run_puppet_apply_on_linux.bind(self).()
         end
-        
+
         define_method(:configure) do |root_config|
-          is_windows ? configure_on_windows(root_config) : configure_on_linux.bind(self).(root_config)
+          is_windows? ? configure_on_windows(root_config) : configure_on_linux.bind(self).(root_config)
         end
         
+        define_method(:provision) do
+          windows_machine = VagrantWindows::WindowsMachine.new(@machine)
+          wait_if_rebooting(windows_machine) if is_windows?
+          provision_on_linux.bind(self).()
+        end
+
         def run_puppet_apply_on_windows
-          options = [config.options].flatten
+          
+          # This re-establishes our symbolic links if they were created between now and a reboot
+          @machine.communicate.execute('& net use a-non-existant-share', :error_check => false)
+          
+          options = [@config.options].flatten
           module_paths = @module_paths.map { |_, to| to }
           if !@module_paths.empty?
             # Prepend the default module path
@@ -28,49 +44,70 @@ module VagrantPlugins
             options << "--modulepath '#{module_paths.join(';')}'"
           end
 
+          if @hiera_config_path
+            options << "--hiera_config=#{@hiera_config_path}"
+          end
+
+          if !@machine.env.ui.is_a?(Vagrant::UI::Colored)
+            options << "--color=false"
+          end
+
+          options << "--manifestdir #{manifests_guest_path}"
+          options << "--detailed-exitcodes"
           options << @manifest_file
           options = options.join(" ")
 
           # Build up the custom facts if we have any
           facter = ""
-          if !config.facter.empty?
+          if !@config.facter.empty?
             facts = []
-            config.facter.each do |key, value|
+            @config.facter.each do |key, value|
               facts << "$env:FACTER_#{key}='#{value}';"
             end
 
             facter = "#{facts.join(" ")} "
           end
-          
-          command = "cd #{manifests_guest_path}; if($?) \{ #{facter} puppet apply #{options} \}"
-          
+
+          command = "#{facter} puppet apply #{options}"
+          if @config.working_directory
+            command = "cd #{@config.working_directory}; if($?) \{ #{command} \}"
+          end
+
           @machine.env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet",
                                       :manifest => @manifest_file)
 
-          @machine.communicate.sudo(command) do |type, data|
+          exit_status = @machine.communicate.sudo(command, :error_check => false) do |type, data|
             if !data.empty?
               @machine.env.ui.info(data, :new_line => false, :prefix => false)
             end
           end
+          
+          # Puppet returns 0 or 2 for success with --detailed-exitcodes
+          if ![0,2].include?(exit_status)
+            raise ::VagrantWindows::Errors::WinRMExecutionError,
+              :shell => :powershell,
+              :command => command,
+              :message => "Puppet failed with an exit code of #{exit_status}"
+          end
         end
-        
+
         def configure_on_windows(root_config)
           # Calculate the paths we're going to use based on the environment
           root_path = @machine.env.root_path
           @expanded_manifests_path = @config.expanded_manifests_path(root_path)
           @expanded_module_paths   = @config.expanded_module_paths(root_path)
-          @manifest_file           = @config.manifest_file
+          @manifest_file           = File.join(manifests_guest_path, @config.manifest_file)
 
           # Setup the module paths
           @module_paths = []
           @expanded_module_paths.each_with_index do |path, i|
-            @module_paths << [path, File.join(config.temp_dir, "modules-#{i}")]
+            @module_paths << [path, File.join(@config.temp_dir, "modules-#{i}")]
           end
 
           @logger.debug("Syncing folders from puppet configure")
           @logger.debug("manifests_guest_path = #{manifests_guest_path}")
           @logger.debug("expanded_manifests_path = #{@expanded_manifests_path}")
-          
+
           # Windows guest volume mounting fails without an "id" specified
           # This hacks around that problem and allows the PS mount script to work
           root_config.vm.synced_folder(
@@ -91,8 +128,8 @@ module VagrantPlugins
           end
         end
 
-        def is_windows
-          @machine.config.vm.guest.eql? :windows
+        def is_windows?
+          VagrantWindows::WindowsMachine.is_windows?(@machine)
         end
 
       end # Puppet class

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

@@ -1,5 +1,6 @@
 require "#{Vagrant::source_root}/plugins/provisioners/shell/provisioner"
 require_relative '../../../../helper'
+require_relative '../../../../windows_machine'
 
 module VagrantPlugins
   module Shell
@@ -11,14 +12,17 @@ module VagrantPlugins
         provision_on_linux = instance_method(:provision)
         
         define_method(:provision) do
-          is_windows ? provision_on_windows() : provision_on_linux.bind(self).()
+          VagrantWindows::WindowsMachine.is_windows?(@machine) ? provision_on_windows() : provision_on_linux.bind(self).()
         end
-
+        
         def provision_on_windows
             args = ""
             args = " #{config.args}" if config.args
 
-            with_script_file do |path|
+            windows_machine = VagrantWindows::WindowsMachine.new(@machine)
+            wait_if_rebooting(windows_machine)
+
+            with_windows_script_file do |path|
             # Upload the script to the machine
             @machine.communicate.tap do |comm|
               # Ensure the uploaded script has a file extension, by default
@@ -59,29 +63,39 @@ module VagrantPlugins
         # This method yields the path to a script to upload and execute
         # on the remote server. This method will properly clean up the
         # script file if needed.
-        def with_script_file
-          if config.path
+        def with_windows_script_file
+          script = nil
+
+          if config.remote?
+            download_path = @machine.env.tmp_path.join("#{@machine.id}-remote-script")
+            download_path.delete if download_path.file?
+
+            Vagrant::Util::Downloader.new(config.path, download_path).download!
+            script = download_path.read
+
+            download_path.delete
+          elsif config.path
             # Just yield the path to that file...
-            yield config.path
+            root_path = @machine.env.root_path
+            script = Pathname.new(config.path).expand_path(root_path).read
           else
-            # Otherwise we have an inline script, we need to Tempfile it,
-            # and handle it specially...
-            file = Tempfile.new(['vagrant-powershell', '.ps1'])
-
-            begin
-              file.write(config.inline)
-              file.fsync
-              file.close
-              yield file.path
-            ensure
-              file.close
-              file.unlink
-            end
+            # The script is just the inline code...
+            script = config.inline
           end
-        end
 
-        def is_windows
-            @machine.config.vm.guest.eql? :windows
+          # Otherwise we have an inline script, we need to Tempfile it,
+          # and handle it specially...
+          file = Tempfile.new(['vagrant-powershell', '.ps1'])
+
+          begin
+            file.write(script)
+            file.fsync
+            file.close
+            yield file.path
+          ensure
+            file.close
+            file.unlink
+          end
         end
 
       end # Provisioner class

data/lib/vagrant-windows/plugin.rb

@@ -76,13 +76,13 @@ module VagrantWindows
       end
 
       guest_capability(:windows, :mount_virtualbox_shared_folder) do
-        require_relative "guest/cap/mount_virtualbox_shared_folder"
-        VagrantWindows::Guest::Cap::MountVirtualBoxSharedFolder
+        require_relative "guest/cap/mount_shared_folder"
+        VagrantWindows::Guest::Cap::MountSharedFolder
       end
 
       guest_capability(:windows, :mount_vmware_shared_folder) do
-        require_relative "guest/cap/mount_vmware_shared_folder"
-        VagrantWindows::Guest::Cap::MountVMwareSharedFolder
+        require_relative "guest/cap/mount_shared_folder"
+        VagrantWindows::Guest::Cap::MountSharedFolder
       end
     
     end

data/lib/vagrant-windows/scripts/cheftask.ps1.erb

@@ -1,8 +1,5 @@
-schtasks /query /tn "chef-solo" | Out-Null
-if ($?) {
-  # task already exists, kill it
-  schtasks /delete /tn "chef-solo" /f | Out-Null
-}
+# kill the task so we can recreate it
+schtasks /delete /tn "chef-solo" /f 2>&1 | out-null
 
 # Ensure the chef task running file doesn't exist from a previous failure
 if (Test-Path "<%= options[:chef_task_running] %>") {
@@ -34,14 +31,18 @@ $success = $TRUE
 while (Test-Path "<%= options[:chef_task_running] %>") {
   Start-Sleep -m 100
   
-  $text = (get-content "<%= options[:chef_stdout_log] %>")
-  $numLines = ($text | Measure-Object -line).lines    
-  $numLinesToRead = $numLines - $numLinesRead
-  
-  $text | select -first $numLinesToRead -skip $numLinesRead | ForEach {
-    Write-Host "$_"
+  if (Test-Path "<%= options[:chef_stdout_log] %>") {
+    $text = (get-content "<%= options[:chef_stdout_log] %>")
+    $numLines = ($text | Measure-Object -line).lines    
+    $numLinesToRead = $numLines - $numLinesRead
+    
+    if ($numLinesToRead -gt 0) {
+      $text | select -first $numLinesToRead -skip $numLinesRead | ForEach {
+        Write-Host "$_"
+      }
+      $numLinesRead += $numLinesToRead
+    }
   }
-  $numLinesRead += $numLinesToRead
 }
 
 exit Get-Content "<%= options[:chef_task_exitcode] %>"

data/lib/vagrant-windows/scripts/cheftask.xml.erb

@@ -34,7 +34,7 @@
     <RunOnlyIfIdle>false</RunOnlyIfIdle>
     <WakeToRun>false</WakeToRun>
     <ExecutionTimeLimit>PT2H</ExecutionTimeLimit>
-    <Priority>7</Priority>
+    <Priority>4</Priority>
   </Settings>
   <Actions Context="Author">
     <Exec>

data/lib/vagrant-windows/scripts/cheftaskrun.ps1.erb

@@ -10,7 +10,9 @@ Try
 Finally
 {
   $exitCode | Out-File "<%= options[:chef_task_exitcode] %>"
-  del "<%= options[:chef_task_running] %>"
+  if (Test-Path "<%= options[:chef_task_running] %>") {
+    del "<%= options[:chef_task_running] %>"
+  }
 }
 
 exit $exitCode

data/lib/vagrant-windows/scripts/{mount_volume.vmware.ps1.erb → mount_volume.ps1.erb}

@@ -7,6 +7,7 @@ function Test-ReparsePoint([string]$path) {
 
 $MountPoint = [System.IO.Path]::GetFullPath("<%= options[:mount_point] %>")
 $ShareName = "<%= options[:share_name] %>"
+$VmProviderUncPath = "<%= options[:vm_provider_unc_path] %>"
 
 # https://github.com/BIAINC/vagrant-windows/issues/4
 # Not sure why this works, but it does.
@@ -41,7 +42,7 @@ if (-not (Test-Path $BaseDirectory))
   New-Item $BaseDirectory -Type Directory -Force | Out-Null
 }
 
-cmd /c mklink /D "$MountPoint" "\\vmware-host\Shared Folders\$ShareName" | out-null
+cmd /c mklink /D "$MountPoint" "$VmProviderUncPath" | out-null
 
 if ( $LASTEXITCODE -ne 0 )
 {

data/lib/vagrant-windows/scripts/reboot_detect.ps1

@@ -0,0 +1,43 @@
+# function to check whether machine is currently shutting down
+function ShuttingDown {
+    [string]$sourceCode = @"
+using System;
+using System.Runtime.InteropServices;
+
+namespace VagrantWindows {
+    public static class RemoteManager {
+        private const int SM_SHUTTINGDOWN = 0x2000;
+
+        [DllImport("User32.dll", CharSet = CharSet.Unicode)]
+        private static extern int GetSystemMetrics(int Index);
+
+        public static bool Shutdown() {
+            return (0 != GetSystemMetrics(SM_SHUTTINGDOWN));
+        }
+    }
+}
+"@
+    $type = Add-Type -TypeDefinition $sourceCode -PassThru
+    return $type::Shutdown()
+}
+
+if (ShuttingDown) {
+  exit 1
+}
+else {
+  # see if a reboot is scheduled in the future by trying to schedule a reboot
+  . shutdown.exe -f -r -t 60
+  
+  if ($LASTEXITCODE -eq 1190) {
+    # reboot is already pending
+    exit 2
+  }
+  
+  # Remove the pending reboot we just created above
+  if ($LASTEXITCODE -eq 0) {
+    . shutdown.exe -a
+  }
+}
+
+# no reboot in progress or scheduled
+exit 0

data/lib/vagrant-windows/version.rb

@@ -1,3 +1,3 @@
 module VagrantWindows
-  VERSION = "1.2.0"
+  VERSION = "1.3.1"
 end

data/lib/vagrant-windows/windows_machine.rb

@@ -0,0 +1,87 @@
+module VagrantWindows
+  
+  # Provides a wrapper around the Vagrant machine object
+  class WindowsMachine
+    
+    attr_reader :machine
+    
+    # Returns true if the specifed Vagrant machine is a Windows guest, otherwise false.
+    #
+    # @param [Machine] The Vagrant machine object
+    # @return [Boolean]
+    def self.is_windows?(machine)
+      machine.config.vm.guest.eql? :windows
+    end
+    
+    # @param [Machine] The Vagrant machine object
+    def initialize(machine)
+      @machine = machine
+      @logger = Log4r::Logger.new("vagrant_windows::windows_machine")
+    end
+    
+    # Checks to see if the machine is using VMWare Fusion or Workstation.
+    #
+    # @return [Boolean]
+    def is_vmware?()
+      @machine.provider_name.to_s().start_with?('vmware')
+    end
+    
+    # Checks to see if the machine is using Oracle VirtualBox.
+    #
+    # @return [Boolean]
+    def is_virtualbox?()
+      @machine.provider_name.to_s().start_with?('virtualbox')
+    end
+    
+    # Checks to see if the machine is rebooting or has a scheduled reboot.
+    #
+    # @return [Boolean] True if rebooting
+    def is_rebooting?()
+      reboot_detect_script = VagrantWindows.load_script('reboot_detect.ps1')
+      @machine.communicate.execute(reboot_detect_script, :error_check => false) != 0
+    end
+    
+    # Returns the active WinRMShell for the guest.
+    #
+    # @return [WinRMShell]
+    def winrmshell()
+      @machine.communicate.winrmshell
+    end
+
+    # Reads the machine's MAC addresses keyed by interface index.
+    # {1=>"0800273FAC5A", 2=>"08002757E68A"}
+    #
+    # @return [Hash]
+    def read_mac_addresses()
+      @machine.provider.driver.read_mac_addresses
+    end
+    
+    # Returns a list of forwarded ports for a VM.
+    # NOTE: Only the VBox provider currently supports this method
+    #
+    # @return [Array<Array>]
+    def read_forwarded_ports()
+      if is_virtualbox?()
+        @machine.provider.driver.read_forwarded_ports
+      else
+        []
+      end
+    end
+    
+    # Returns the SSH config for this machine.
+    #
+    # @return [Hash]
+    def ssh_info()
+      @machine.ssh_info
+    end
+    
+    def windows_config()
+      @machine.config.windows
+    end
+    
+    def winrm_config()
+      @machine.config.winrm
+    end
+    
+  end
+end

data/locales/en.yml

@@ -2,11 +2,8 @@ en:
   vagrant_windows:
 
     errors:
-      winrm_port_not_detected: |-
-        Vagrant could not detect the WinRM port.
-
-        Host port: %{port}
-        Guest port: %{guest_port}
+      winrm_not_ready: |-
+        The box is not ready for WinRM connections yet.
       winrm_invalid_shell: |-
         %{shell} is not a supported type of Windows shell.
       winrm_execution_error: |-

data/spec/vagrant-windows/guestnetwork_spec.rb

@@ -5,7 +5,7 @@ describe VagrantWindows::Communication::GuestNetwork , :integration => true do
   before(:all) do
     # This test requires you already have a running Windows Server 2008 R2 Vagrant VM
     # Not ideal, but you have to start somewhere
-    @shell = VagrantWindows::Communication::WinRMShell.new("localhost", "vagrant", "vagrant")
+    @shell = VagrantWindows::Communication::WinRMShell.new("127.0.0.1", "vagrant", "vagrant")
     @guestnetwork = VagrantWindows::Communication::GuestNetwork.new(@shell)
   end
   
@@ -35,8 +35,20 @@ describe VagrantWindows::Communication::GuestNetwork , :integration => true do
     
     it "should configure static IP for adapter" do
       nics = @guestnetwork.network_adapters()
-      @guestnetwork.configure_static_interface(nics[1][:index], nics[1][:net_connection_id], "192.168.0.100", "255.255.255.0")
+      @guestnetwork.configure_static_interface(
+        nics[1][:index],
+        nics[1][:net_connection_id],
+        "192.168.0.121",
+        "255.255.255.0")
+        
       expect(@guestnetwork.is_dhcp_enabled(nics[1][:index])).to be_false
+      
+      # ensure the right IP was set by looking through all the output of ipconfig
+      ipconfig_out = ''
+      @shell.powershell('ipconfig /all') do |_, line|
+        ipconfig_out = ipconfig_out + "#{line}"
+      end
+      expect(ipconfig_out).to include('192.168.0.121')
     end
     
     it "should configure all networks to work mode" do

data/spec/vagrant-windows/helper_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'mocha/api'
 
 describe VagrantWindows::Helper , :unit => true do
   

data/spec/vagrant-windows/mount_shared_folder_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'mocha/api'
+require 'vagrant-windows/guest/cap/mount_shared_folder'
+
+describe VagrantWindows::Guest::Cap::MountSharedFolder, :unit => true do
+  
+  before(:each) do
+    @communicator = mock()
+    @machine = stub(:communicate => @communicator)
+  end
+
+  describe "mount_virtualbox_shared_folder" do
+    it "should run script with vbox paths"  do
+      @communicator.expects(:execute).with do |script, options|
+        expect(script).to include("$VmProviderUncPath = \"\\\\vboxsrv\\vagrant\"")
+      end      
+
+      VagrantWindows::Guest::Cap::MountSharedFolder.mount_virtualbox_shared_folder(
+        @machine, "vagrant", "/tmp/vagrant", {})
+    end
+  end
+    
+  describe "mount_vmware_shared_folder" do
+    it "should run script with vmware paths"  do
+      @communicator.expects(:execute).with do |script, options|
+        expect(script).to include("$VmProviderUncPath = \"\\\\vmware-host\\Shared Folders\\vagrant\"")
+      end
+      
+      VagrantWindows::Guest::Cap::MountSharedFolder.mount_vmware_shared_folder(
+        @machine, "vagrant", "/tmp/vagrant", {})
+    end
+  end
+  
+end

data/spec/vagrant-windows/windows_config_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe VagrantWindows::Config::Windows , :unit => true do
+  let(:instance) { described_class.new }
+
+  describe "defaults" do
+    subject do
+      instance.tap do |o|
+        o.finalize!
+      end
+    end
+
+    its("halt_timeout")        { should == 30 }
+    its("halt_check_interval") { should == 1 }
+  end
+
+  describe "overriding defaults" do
+    [:halt_timeout, :halt_check_interval].each do |attribute|
+      it "should not default #{attribute} if overridden" do
+        instance.send("#{attribute}=".to_sym, 10)
+        instance.finalize!
+        instance.send(attribute).should == 10
+      end
+    end
+  end
+end