vagrant-windows 1.2.0 → 1.3.1

data/init.pp

@@ -0,0 +1,5 @@
+file {'c:/hellopuppet.txt':
+  ensure => present,
+  content => 'yo dawg you did its!'
+}
+

data/lib/vagrant-windows/communication/winrmcommunicator.rb

@@ -1,37 +1,36 @@
 require 'timeout'
 require 'log4r'
-require_relative '../errors'
+require_relative 'winrmshell_factory'
 require_relative 'winrmshell'
 require_relative 'winrmfinder'
+require_relative '../errors'
+require_relative '../windows_machine'
 
 module VagrantWindows
   module Communication
-    # Provides communication with the VM via WinRM.
+    # Provides communication channel for Vagrant commands via WinRM.
     class WinRMCommunicator < Vagrant.plugin("2", :communicator)
-
-      attr_reader :logger
-      attr_reader :machine
-      attr_reader :winrm_finder
       
       def self.match?(machine)
-        machine.config.vm.guest.eql? :windows
+        VagrantWindows::WindowsMachine.is_windows?(machine)
       end
 
       def initialize(machine)
-        @machine = machine
+        @windows_machine = VagrantWindows::WindowsMachine.new(machine)
+        @winrm_shell_factory = WinRMShellFactory.new(@windows_machine, WinRMFinder.new(@windows_machine))
+        
         @logger = Log4r::Logger.new("vagrant_windows::communication::winrmcommunicator")
         @logger.debug("initializing WinRMCommunicator")
-        @winrm_finder = WinRMFinder.new(machine)
       end
 
       def ready?
-        logger.debug("Checking whether WinRM is ready...")
+        @logger.debug("Checking whether WinRM is ready...")
 
-        Timeout.timeout(@machine.config.winrm.timeout) do
-          session.powershell("hostname")
+        Timeout.timeout(@windows_machine.winrm_config.timeout) do
+          winrmshell.powershell("hostname")
         end
 
-        logger.info("WinRM is ready!")
+        @logger.info("WinRM is ready!")
         return true
         
       rescue Vagrant::Errors::VagrantError => e
@@ -42,79 +41,68 @@ module VagrantWindows
       end
       
       def execute(command, opts={}, &block)
-        if opts[:shell].eql? :cmd
-          session.cmd(command, &block)[:exitcode]
-        else
-          command = VagrantWindows.load_script("command_alias.ps1") << "\r\n" << command
-          session.powershell(command, &block)[:exitcode]
+        opts = {
+          :error_check => true,
+          :error_class => VagrantWindows::Errors::WinRMExecutionError,
+          :error_key   => :winrm_execution_error,
+          :command     => command,
+          :shell       => :powershell
+        }.merge(opts || {})
+        exit_status = do_execute(command, opts[:shell], &block)
+        if opts[:error_check] && exit_status != 0
+          raise_execution_error(opts, exit_status)
         end
+        exit_status
       end
       alias_method :sudo, :execute
       
       def test(command, opts=nil)
+        @logger.debug("Testing: #{command}")
+        
         # HACK: to speed up Vagrant 1.2 OS detection, skip checking for *nix OS
         return false unless (command =~ /^uname|^cat \/etc|^cat \/proc|grep 'Fedora/).nil?
-        execute(command) == 0
+
+        opts = { :error_check => false }.merge(opts || {})
+        execute(command, opts) == 0
       end
 
       def upload(from, to)
         @logger.debug("Uploading: #{from} to #{to}")
-        file = "winrm-upload-#{rand()}"
-        file_name = (session.cmd("echo %TEMP%\\#{file}"))[:data][0][:stdout].chomp
-        session.powershell <<-EOH
-          if(Test-Path #{to})
-          {
-            rm #{to}
-          }
-        EOH
-        Base64.encode64(IO.binread(from)).gsub("\n",'').chars.to_a.each_slice(8000-file_name.size) do |chunk|
-          out = session.cmd("echo #{chunk.join} >> \"#{file_name}\"")
-        end
-        session.powershell("mkdir $([System.IO.Path]::GetDirectoryName(\"#{to}\"))")
-        session.powershell <<-EOH
-          $base64_string = Get-Content \"#{file_name}\"
-          $bytes  = [System.Convert]::FromBase64String($base64_string) 
-          $new_file = [System.IO.Path]::GetFullPath(\"#{to}\")
-          [System.IO.File]::WriteAllBytes($new_file,$bytes)
-        EOH
+        winrmshell.upload(from, to)
       end
       
       def download(from, to=nil)
         @logger.warn("Downloading: #{from} to #{to} not supported on Windows guests")
       end
       
-      # Runs a remote WQL query against the VM
-      #
-      # Note: This is not part of the standard Vagrant communicator interface, but
-      # guest capabilities may need to use this.
-      def wql(query)
-        session.wql(query)
-      end
-      
-      def set_winrmshell(winrmshell)
-        @session = winrmshell
+      def winrmshell=(winrmshell)
+        @winrmshell = winrmshell
       end
       
-      def session
-        @session ||= new_session
+      def winrmshell
+        @winrmshell ||= @winrm_shell_factory.create_winrm_shell()
       end
-      alias_method :winrmshell, :session
       
       
       protected
       
-      def new_session
-        WinRMShell.new(
-          @winrm_finder.winrm_host_address(),
-          @machine.config.winrm.username,
-          @machine.config.winrm.password,
-          {
-            :port => @winrm_finder.winrm_host_port(),
-            :timeout_in_seconds => @machine.config.winrm.timeout,
-            :max_tries => @machine.config.winrm.max_tries
-          })
+      def do_execute(command, shell, &block)
+        if shell.eql? :cmd
+          winrmshell.cmd(command, &block)[:exitcode]
+        else
+          command = VagrantWindows.load_script("command_alias.ps1") << "\r\n" << command << "\r\nexit $LASTEXITCODE"
+          winrmshell.powershell(command, &block)[:exitcode]
+        end
+      end
+      
+      def raise_execution_error(opts, exit_code)
+        # The error classes expect the translation key to be _key, but that makes for an ugly
+        # configuration parameter, so we set it here from `error_key`
+        msg = "Command execution failed with an exit code of #{exit_code}"
+        error_opts = opts.merge(:_key => opts[:error_key], :message => msg)
+        raise opts[:error_class], error_opts
       end
       
     end #WinRM class
   end
-end
+end

data/lib/vagrant-windows/communication/winrmfinder.rb

@@ -1,43 +1,49 @@
 require 'log4r'
 require_relative '../errors'
+require_relative '../windows_machine'
 
 module VagrantWindows
   module Communication
     class WinRMFinder
 
       attr_reader :logger
-      attr_reader :machine
+      attr_reader :windows_machine
     
-      def initialize(machine)
-        @machine = machine
+      def initialize(windows_machine)
+        @windows_machine = windows_machine
         @logger = Log4r::Logger.new("vagrant_windows::communication::winrmfinder")
       end
 
+      # Finds the address of the Windows machine.
+      # Raises a Vagrant::Errors::SSHNotReady if WinRM is not responding yet.
+      #
+      # @return [String] The IP of the Windows machine
       def winrm_host_address
         # Get the SSH info for the machine, raise an exception if the
-        # provider is saying that SSH is not ready.
-        ssh_info = @machine.ssh_info
-        raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
-        @logger.info("WinRM host: #{ssh_info[:host]}")
-        return ssh_info[:host]
+        # provider is saying that the machine is not ready.
+        ssh_info = @windows_machine.ssh_info
+        raise VagrantWindows::Errors::WinRMNotReady if ssh_info.nil?
+        
+        # if the configuration has a host value, that takes precedence
+        host = @windows_machine.winrm_config.host || ssh_info[:host]
+        @logger.info("WinRM host: #{host}")
+        host
       end
       
+      # Finds the IP port of the Windows machine's WinRM service.
+      #
+      # @return [String] The port of the Windows machine's WinRM service
       def winrm_host_port
-        expected_guest_port = @machine.config.winrm.guest_port
+        expected_guest_port = @windows_machine.winrm_config.guest_port
         @logger.debug("Searching for WinRM port: #{expected_guest_port.inspect}")
 
         # Look for the forwarded port only by comparing the guest port
-        begin
-          @machine.provider.driver.read_forwarded_ports.each do |_, _, hostport, guestport|
-            return hostport if guestport == expected_guest_port
-          end
-        rescue NoMethodError => e
-          # VMWare provider doesn't support read_forwarded_ports
-          @logger.debug(e.message)
+        @windows_machine.read_forwarded_ports().each do |_, _, hostport, guestport|
+          return hostport if guestport == expected_guest_port
         end
         
         # We tried, give up and use the configured port as-is
-        @machine.config.winrm.port
+        @windows_machine.winrm_config.port
       end
       
     end

data/lib/vagrant-windows/communication/winrmshell.rb

@@ -56,30 +56,48 @@ module VagrantWindows
       def wql(query)
         execute_wql(query)
       end
+      
+      def upload(from, to)
+        @logger.debug("Uploading: #{from} to #{to}")
+        file_name = (cmd("echo %TEMP%\\winrm-upload-#{rand()}"))[:data][0][:stdout].chomp
+        powershell <<-EOH
+          if(Test-Path #{to}) {
+            rm #{to}
+          }
+        EOH
+        Base64.encode64(IO.binread(from)).gsub("\n",'').chars.to_a.each_slice(8000-file_name.size) do |chunk|
+          out = cmd("echo #{chunk.join} >> \"#{file_name}\"")
+        end
+        powershell <<-EOH
+          mkdir $([System.IO.Path]::GetDirectoryName(\"#{to}\"))
+          $base64_string = Get-Content \"#{file_name}\"
+          $bytes  = [System.Convert]::FromBase64String($base64_string) 
+          $new_file = [System.IO.Path]::GetFullPath(\"#{to}\")
+          [System.IO.File]::WriteAllBytes($new_file,$bytes)
+        EOH
+      end
 
       protected
       
       def execute_shell(command, shell=:powershell, &block)
+        raise Errors::WinRMInvalidShell, :shell => shell unless shell == :cmd || shell == :powershell
+        begin
+          execute_shell_with_retry(command, shell, &block)
+        rescue => e
+          raise_winrm_exception(e, shell, command)
+        end
+      end
+      
+      def execute_shell_with_retry(command, shell, &block)
         retryable(:tries => @max_tries, :on => @@exceptions_to_retry_on, :sleep => 10) do
           @logger.debug("#{shell} executing:\n#{command}")
-          if shell.eql? :cmd
-            output = session.cmd(command) do |out, err|
-              block.call(:stdout, out) if block_given? && out
-              block.call(:stderr, err) if block_given? && err
-            end
-          elsif shell.eql? :powershell
-            output = session.powershell(command) do |out, err|
-              block.call(:stdout, out) if block_given? && out
-              block.call(:stderr, err) if block_given? && err
-            end
-          else
-            raise Errors::WinRMInvalidShell, :shell => shell
+          output = session.send(shell, command) do |out, err|
+            block.call(:stdout, out) if block_given? && out
+            block.call(:stderr, err) if block_given? && err
           end
           @logger.debug("Exit status: #{output[:exitcode].inspect}")
           return output
         end
-      rescue => e
-        handle_winrm_exception(e, shell, command)
       end
       
       def execute_wql(query)
@@ -90,10 +108,10 @@ module VagrantWindows
           return output
         end
       rescue => e
-        handle_winrm_exception(e, :wql, query)
+        raise_winrm_exception(e, :wql, query)
       end
       
-      def handle_winrm_exception(winrm_exception, shell, command)
+      def raise_winrm_exception(winrm_exception, shell, command)
         if winrm_exception.message.include?("401") # return a more specific auth error for 401 errors
           raise Errors::WinRMAuthorizationError,
             :user => @username,

data/lib/vagrant-windows/communication/winrmshell_factory.rb

@@ -0,0 +1,34 @@
+require_relative 'winrmshell'
+require_relative 'winrmfinder'
+
+module VagrantWindows
+  module Communication
+    
+    # Factory class for generating new WinRMShell instances
+    class WinRMShellFactory
+
+      # @param [WindowsMachine] The Windows machine instance
+      # @param [WinRMFinder] The WinRMFinder instance
+      def initialize(windows_machine, winrm_finder)
+        @windows_machine = windows_machine
+        @winrm_finder = winrm_finder
+      end
+      
+      # Creates a new WinRMShell instance
+      #
+      # @return [WinRMShell]
+      def create_winrm_shell()
+        WinRMShell.new(
+          @winrm_finder.winrm_host_address(),
+          @windows_machine.winrm_config.username,
+          @windows_machine.winrm_config.password,
+          {
+            :port => @winrm_finder.winrm_host_port(),
+            :timeout_in_seconds => @windows_machine.winrm_config.timeout,
+            :max_tries => @windows_machine.winrm_config.max_tries
+          })
+      end
+      
+    end #WinShell class
+  end
+end

data/lib/vagrant-windows/config/winrm.rb

@@ -27,7 +27,6 @@ module VagrantWindows
 
         errors << "winrm.username cannot be nil."   if machine.config.winrm.username.nil?
         errors << "winrm.password cannot be nil."   if machine.config.winrm.password.nil?
-        errors << "winrm.host cannot be nil."       if machine.config.winrm.host.nil?
         errors << "winrm.port cannot be nil."       if machine.config.winrm.port.nil?
         errors << "winrm.guest_port cannot be nil." if machine.config.winrm.guest_port.nil?
         errors << "winrm.max_tries cannot be nil."  if machine.config.winrm.max_tries.nil?
@@ -39,7 +38,7 @@ module VagrantWindows
       def finalize!
         @username = "vagrant" if @username == UNSET_VALUE
         @password = "vagrant" if @password == UNSET_VALUE
-        @host = "localhost"   if @host == UNSET_VALUE
+        @host = nil           if @host == UNSET_VALUE
         @port = 5985          if @port == UNSET_VALUE
         @guest_port = 5985    if @guest_port == UNSET_VALUE
         @max_tries = 20       if @max_tries == UNSET_VALUE

data/lib/vagrant-windows/errors.rb

@@ -7,8 +7,8 @@ module VagrantWindows
       error_namespace("vagrant_windows.errors")
     end  
     
-    class WinRMPortNotDetected < VagrantWindowsError
-      error_key(:winrm_port_not_detected)
+    class WinRMNotReady < VagrantWindowsError
+      error_key(:winrm_not_ready)
     end
 
     class WinRMInvalidShell < VagrantWindowsError

data/lib/vagrant-windows/guest/cap/configure_networks.rb

@@ -2,6 +2,8 @@ require 'log4r'
 require_relative '../../communication/guestnetwork'
 require_relative '../../communication/winrmshell'
 require_relative '../../errors'
+require_relative '../../helper'
+require_relative '../../windows_machine'
 
 module VagrantWindows
   module Guest
@@ -13,47 +15,49 @@ module VagrantWindows
         def self.configure_networks(machine, networks)
           @@logger.debug("networks: #{networks.inspect}")
           
-          guest_network = ::VagrantWindows::Communication::GuestNetwork.new(machine.communicate.winrmshell)
-
-          if (machine.provider_name != :vmware_fusion) && (machine.provider_name != :vmware_workstation)
-            vm_interface_map = create_vm_interface_map(machine, guest_network)
-          end
-          
-          networks.each do |network|
-            interface = vm_interface_map[network[:interface]+1]
-            if interface.nil?
-              @@logger.warn("Could not find interface for network #{network.inspect}")
-              next
-            end
-            network_type = network[:type].to_sym
-            if network_type == :static
-              guest_network.configure_static_interface(
-                interface[:index],
-                interface[:net_connection_id],
-                network[:ip],
-                network[:netmask])
-            elsif network_type == :dhcp
-              guest_network.configure_dhcp_interface(
-                interface[:index],
-                interface[:net_connection_id])
-            else
-              raise WindowsError, "#{network_type} network type is not supported, try static or dhcp"
+          windows_machine = VagrantWindows::WindowsMachine.new(machine)
+          guest_network = VagrantWindows::Communication::GuestNetwork.new(windows_machine.winrmshell)
+          if windows_machine.is_vmware?()
+            @@logger.warn('Configuring secondary network adapters through VMware is not yet supported.')
+            @@logger.warn('You will need to manually configure the network adapter.')
+          else
+            vm_interface_map = create_vm_interface_map(windows_machine, guest_network)          
+            networks.each do |network|
+              interface = vm_interface_map[network[:interface]+1]
+              if interface.nil?
+                @@logger.warn("Could not find interface for network #{network.inspect}")
+                next
+              end
+              network_type = network[:type].to_sym
+              if network_type == :static
+                guest_network.configure_static_interface(
+                  interface[:index],
+                  interface[:net_connection_id],
+                  network[:ip],
+                  network[:netmask])
+              elsif network_type == :dhcp
+                guest_network.configure_dhcp_interface(
+                  interface[:index],
+                  interface[:net_connection_id])
+              else
+                raise WindowsError, "#{network_type} network type is not supported, try static or dhcp"
+              end
             end
           end
-          guest_network.set_all_networks_to_work() if machine.config.windows.set_work_network
+          guest_network.set_all_networks_to_work() if windows_machine.windows_config.set_work_network
         end
         
         #{1=>{:name=>"Local Area Connection", :mac_address=>"0800275FAC5B", :interface_index=>"11", :index=>"7"}}
-        def self.create_vm_interface_map(machine, guest_network)
+        def self.create_vm_interface_map(windows_machine, guest_network)
           vm_interface_map = {}
-          driver_mac_address = machine.provider.driver.read_mac_addresses.invert
+          driver_mac_address = windows_machine.read_mac_addresses.invert
           @@logger.debug("mac addresses: #{driver_mac_address.inspect}")
           guest_network.network_adapters().each do |nic|
             @@logger.debug("nic: #{nic.inspect}")
             naked_mac = nic[:mac_address].gsub(':','')
             if driver_mac_address[naked_mac]
               vm_interface_map[driver_mac_address[naked_mac]] = {
-                :name => nic[:net_connection_id],
+                :net_connection_id => nic[:net_connection_id],
                 :mac_address => naked_mac,
                 :interface_index => nic[:interface_index],
                 :index => nic[:index] }

data/lib/vagrant-windows/guest/cap/halt.rb

@@ -3,6 +3,10 @@ module VagrantWindows
     module Cap
       class Halt
         def self.halt(machine)
+          # Fix defect 129, if there's an existing scheduled reboot cancel it so shutdown succeeds
+          machine.communicate.execute("shutdown -a", :error_check => false)
+          
+          # Force shutdown the machine now
           machine.communicate.execute("shutdown /s /t 1 /c \"Vagrant Halt\" /f /d p:4:1")
 
           # Wait until the VM's state is actually powered off. If this doesn't

data/lib/vagrant-windows/guest/cap/mount_shared_folder.rb

@@ -0,0 +1,31 @@
+require_relative '../../helper'
+
+module VagrantWindows
+  module Guest
+    module Cap
+      class MountSharedFolder
+        
+        def self.mount_virtualbox_shared_folder(machine, name, guestpath, options)
+          mount_shared_folder(machine, name, guestpath, "\\\\vboxsrv\\")
+        end
+        
+        def self.mount_vmware_shared_folder(machine, name, guestpath, options)
+          mount_shared_folder(machine, name, guestpath, "\\\\vmware-host\\Shared Folders\\")
+        end
+        
+        protected
+        
+        def self.mount_shared_folder(machine, name, guestpath, vm_provider_unc_base)
+          share_name = VagrantWindows::Helper.win_friendly_share_id(name)
+          options = {
+            :mount_point => guestpath,
+            :share_name => share_name,
+            :vm_provider_unc_path => vm_provider_unc_base + share_name}
+          mount_script = VagrantWindows.load_script_template("mount_volume.ps1", :options => options)
+          machine.communicate.execute(mount_script, {:shell => :powershell})
+        end
+        
+      end
+    end
+  end
+end

data/lib/vagrant-windows/guest/windows.rb

@@ -1,22 +1,24 @@
 require "vagrant"
+require "vagrant-windows/helper"
 require "vagrant-windows/guest/cap/change_host_name"
 require "vagrant-windows/guest/cap/configure_networks"
 require "vagrant-windows/guest/cap/halt"
-require "vagrant-windows/guest/cap/mount_virtualbox_shared_folder"
-require "vagrant-windows/guest/cap/mount_vmware_shared_folder"
+require "vagrant-windows/guest/cap/mount_shared_folder"
 
 module VagrantWindows
   module Guest
     class Windows < Vagrant.plugin("2", :guest)
       
-      # Vagrant 1.1.x compatibibility methods
+      # Vagrant 1.1.x compatibility methods
       # Implement the 1.1.x methods and call through to the new 1.2.x capabilities
       
+      attr_reader :windows_machine
       attr_reader :machine
       
       def initialize(machine = nil)
         super(machine) unless machine == nil
         @machine = machine
+        @windows_machine = ::VagrantWindows::WindowsMachine.new(machine)
       end
       
       def change_host_name(name)
@@ -31,14 +33,14 @@ module VagrantWindows
         VagrantWindows::Guest::Cap::Halt.halt(@machine)
       end
       
-      def mount_virtualbox_shared_folder(name, guestpath, options)
-        VagrantWindows::Guest::Cap::MountVirtualBoxSharedFolder.mount_virtualbox_shared_folder(
-          @machine, name, guestpath, options)
-      end
-
-      def mount_vmware_shared_folder(name, guestpath, options)
-        VagrantWindows::Guest::Cap::MountVMwareBoxSharedFolder.mount_vmware_shared_folder(
+      def mount_shared_folder(name, guestpath, options)
+        if @windows_machine.is_vmware?() then
+          VagrantWindows::Guest::Cap::MountSharedFolder.mount_vmware_shared_folder(
+            @machine, name, guestpath, options)
+        else
+          VagrantWindows::Guest::Cap::MountSharedFolder.mount_virtualbox_shared_folder(
             @machine, name, guestpath, options)
+        end
       end
       
       def configure_networks(networks)
@@ -46,7 +48,7 @@ module VagrantWindows
       end
       
       
-      # Vagrant 1.2.x compatibibility methods
+      # Vagrant 1.2.x compatibility methods
       
       def detect?(machine)
         

data/lib/vagrant-windows/helper.rb

@@ -2,6 +2,12 @@ module VagrantWindows
   module Helper
     extend self
     
+    @@logger = Log4r::Logger.new("vagrant_windows::helper")
+    
+    # Makes a path Windows guest friendly.
+    # Turns '/vagrant' into 'c:\vagrant'
+    #
+    # @return [String]
     def win_friendly_path(path)
       if path
         new_path = path.gsub('/', '\\')
@@ -10,10 +16,25 @@ module VagrantWindows
       new_path
     end
 
-    # turns '/vagrant' into 'vagrant' or turns ''/a/b/c/d/e' into 'a_b_c_d_e'
+    # Makes Vagrant share names Windows guest friendly.
+    # Turns '/vagrant' into 'vagrant' or turns ''/a/b/c/d/e' into 'a_b_c_d_e'
+    #
+    # @return [String]
     def win_friendly_share_id(shared_folder_name)
       return shared_folder_name.gsub(/[\/\/]/,'_').sub(/^_/, '')
     end
     
+    # Check to see if the guest is rebooting, if its rebooting then wait until its ready
+    #
+    # @param [WindowsMachine] The windows machine instance
+    # @param [Int] The time in seconds to wait between checks
+    def wait_if_rebooting(windows_machine, wait_in_seconds=10)
+      @@logger.info('Checking guest reboot status')
+      while windows_machine.is_rebooting? 
+        @@logger.debug('Guest is rebooting, waiting 10 seconds...')
+        sleep(wait_in_seconds)
+      end
+    end
+
   end
 end