vagrant-windows 1.3.0.pre.2 → 1.3.0.pre.3

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
@@ -69,56 +68,30 @@ module VagrantWindows
 
       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)
+      def winrmshell=(winrmshell)
+        @winrmshell = winrmshell
       end
       
-      def set_winrmshell(winrmshell)
-        @session = winrmshell
+      def winrmshell
+        @winrmshell ||= @winrm_shell_factory.create_winrm_shell()
       end
       
-      def session
-        @session ||= new_session
-      end
-      alias_method :winrmshell, :session
-      
       
       protected
       
       def do_execute(command, shell, &block)
         if shell.eql? :cmd
-          session.cmd(command, &block)[:exitcode]
+          winrmshell.cmd(command, &block)[:exitcode]
         else
           command = VagrantWindows.load_script("command_alias.ps1") << "\r\n" << command
-          session.powershell(command, &block)[:exitcode]
+          winrmshell.powershell(command, &block)[:exitcode]
         end
       end
       
@@ -130,18 +103,6 @@ module VagrantWindows
         raise opts[:error_class], error_opts
       end
       
-      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
-          })
-      end
-      
     end #WinRM class
   end
-end
+end

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

@@ -1,46 +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 the machine is not ready.
-        ssh_info = @machine.ssh_info
+        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 = @machine.config.winrm.host || ssh_info[:host]
+        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,6 +56,26 @@ 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
       

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/guest/cap/configure_networks.rb

@@ -3,6 +3,7 @@ require_relative '../../communication/guestnetwork'
 require_relative '../../communication/winrmshell'
 require_relative '../../errors'
 require_relative '../../helper'
+require_relative '../../windows_machine'
 
 module VagrantWindows
   module Guest
@@ -14,9 +15,10 @@ module VagrantWindows
         def self.configure_networks(machine, networks)
           @@logger.debug("networks: #{networks.inspect}")
           
-          guest_network = ::VagrantWindows::Communication::GuestNetwork.new(machine.communicate.winrmshell)
-          unless VagrantWindows::Helper.is_vmware(machine) 
-            vm_interface_map = create_vm_interface_map(machine, guest_network)
+          windows_machine = VagrantWindows::WindowsMachine.new(machine)
+          guest_network = VagrantWindows::Communication::GuestNetwork.new(windows_machine.winrmshell)
+          unless windows_machine.is_vmware?() 
+            vm_interface_map = create_vm_interface_map(windows_machine, guest_network)
           end
           
           networks.each do |network|
@@ -40,13 +42,13 @@ module VagrantWindows
               raise WindowsError, "#{network_type} network type is not supported, try static or dhcp"
             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}")

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/windows.rb

@@ -12,11 +12,13 @@ module VagrantWindows
       # 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)
@@ -32,7 +34,7 @@ module VagrantWindows
       end
       
       def mount_shared_folder(name, guestpath, options)
-        if VagrantWindows::Helper.is_vmware(@machine) then
+        if @windows_machine.is_vmware?() then
           VagrantWindows::Guest::Cap::MountSharedFolder.mount_vmware_shared_folder(
             @machine, name, guestpath, options)
         else

data/lib/vagrant-windows/helper.rb

@@ -2,6 +2,8 @@ module VagrantWindows
   module Helper
     extend self
     
+    @@logger = Log4r::Logger.new("vagrant_windows::helper")
+    
     # Makes a path Windows guest friendly.
     # Turns '/vagrant' into 'c:\vagrant'
     #
@@ -22,12 +24,17 @@ module VagrantWindows
       return shared_folder_name.gsub(/[\/\/]/,'_').sub(/^_/, '')
     end
     
-    # Checks to see if the specified machine is using VMWare Fusion or Workstation.
+    # Check to see if the guest is rebooting, if its rebooting then wait until its ready
     #
-    # @return [Boolean]
-    def is_vmware(machine)
-      machine.provider_name.to_s().start_with?('vmware')
+    # @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

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
@@ -14,25 +15,16 @@ module VagrantPlugins
 
         # 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
-          wait_if_rebooting() if is_windows
+          windows_machine = VagrantWindows::WindowsMachine.new(@machine)
+          wait_if_rebooting(windows_machine) if is_windows?
           provision_on_linux.bind(self).()
         end
         
-        def wait_if_rebooting
-          # Check to see if the guest is rebooting, if its rebooting then wait until its ready
-          @logger.info('Checking guest reboot status')
-          
-          while is_rebooting?(machine) 
-            @logger.debug('Guest is rebooting, waiting 10 seconds...')
-            sleep(10)
-          end
-        end
-        
-        def run_chef_solo_on_windows          
+        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)
 
@@ -116,13 +108,8 @@ module VagrantPlugins
           @chef_script_options
         end
         
-        def is_rebooting?(machine)
-          reboot_detect_script = VagrantWindows.load_script('reboot_detect.ps1')
-          @machine.communicate.execute(reboot_detect_script, :error_check => false) != 0
-        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,20 +1,31 @@
 require "#{Vagrant::source_root}/plugins/provisioners/puppet/provisioner/puppet"
+require_relative '../../../../../windows_machine'
+require_relative '../../../../../helper'
 
 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
@@ -108,8 +119,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,13 +12,16 @@ 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
 
+            windows_machine = VagrantWindows::WindowsMachine.new(@machine)
+            wait_if_rebooting(windows_machine)
+
             with_script_file do |path|
             # Upload the script to the machine
             @machine.communicate.tap do |comm|
@@ -80,10 +84,6 @@ module VagrantPlugins
           end
         end
 
-        def is_windows
-            @machine.config.vm.guest.eql? :windows
-        end
-
       end # Provisioner class
   end
 end

data/lib/vagrant-windows/version.rb

@@ -1,3 +1,3 @@
 module VagrantWindows
-  VERSION = "1.3.0.pre.2"
+  VERSION = "1.3.0.pre.3"
 end

data/lib/vagrant-windows/windows_machine.rb

@@ -0,0 +1,76 @@
+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 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: For VMWare this is currently unsupported.
+    #
+    # @return [Array<Array>]
+    def read_forwarded_ports()
+      is_vmware?() ? [] : @machine.provider.driver.read_forwarded_ports
+    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/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
   

data/spec/vagrant-windows/helper_spec.rb

@@ -35,23 +35,5 @@ describe VagrantWindows::Helper , :unit => true do
     end
 
   end
-  
-  describe "is_vmware" do
-    it "should be true for vmware_fusion" do
-      machine = stub(:provider_name => :vmware_fusion)
-      expect(@dummy.is_vmware(machine)).to be_true
-    end
-    
-    it "should be true for vmware_workstation" do
-      machine = stub(:provider_name => :vmware_workstation)
-      expect(@dummy.is_vmware(machine)).to be_true
-    end
-    
-    it "should be false for virtual_box" do
-      machine = stub(:provider_name => :virtual_box)
-      expect(@dummy.is_vmware(machine)).to be_false
-    end
-
-  end
 
 end

data/spec/vagrant-windows/windows_machine_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'mocha/api'
+require 'vagrant-windows/windows_machine'
+
+describe VagrantWindows::WindowsMachine , :unit => true do
+  
+  describe "is_vmware?" do
+    it "should be true for vmware_fusion" do
+      machine = stub(:provider_name => :vmware_fusion)
+      windows_machine = VagrantWindows::WindowsMachine.new(machine)
+      expect(windows_machine.is_vmware?()).to be_true
+    end
+    
+    it "should be true for vmware_workstation" do
+      machine = stub(:provider_name => :vmware_workstation)
+      windows_machine = VagrantWindows::WindowsMachine.new(machine)
+      expect(windows_machine.is_vmware?()).to be_true
+    end
+    
+    it "should be false for virtual_box" do
+      machine = stub(:provider_name => :virtual_box)
+      windows_machine = VagrantWindows::WindowsMachine.new(machine)
+      expect(windows_machine.is_vmware?()).to be_false
+    end
+  end
+  
+  describe "is_windows?" do
+    it "should return true when config vm guest is windows" do
+      vm = stub(:guest => :windows)
+      config = stub(:vm => vm)
+      machine = stub(:config => config)
+      expect(VagrantWindows::WindowsMachine.is_windows?(machine)).to be_true
+    end
+    
+    it "should return false when config vm guest is not windows" do
+      vm = stub(:guest => :ubuntu)
+      config = stub(:vm => vm)
+      machine = stub(:config => config)
+      expect(VagrantWindows::WindowsMachine.is_windows?(machine)).to be_false
+    end
+
+  end
+
+end

data/spec/vagrant-windows/winrmcommunicator_spec.rb

@@ -5,9 +5,8 @@ describe VagrantWindows::Communication::WinRMCommunicator, :integration => true
   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")
     @communicator = VagrantWindows::Communication::WinRMCommunicator.new({})
-    @communicator.set_winrmshell(@shell)
+    @communicator.winrmshell = VagrantWindows::Communication::WinRMShell.new("127.0.0.1", "vagrant", "vagrant")
   end
   
   describe "execute" do
@@ -24,5 +23,25 @@ describe VagrantWindows::Communication::WinRMCommunicator, :integration => true
       expect { @communicator.execute("exit 1", opts) }.to raise_error(VagrantWindows::Errors::WinRMInvalidShell)
     end
   end
+  
+  describe "upload" do
+    it "should upload the file and overwrite it if it exists" do
+      test_file = Tempfile.new("uploadtest")
+      IO.write(test_file, "hello world")
+      @communicator.upload(test_file, "c:\\vagrantuploadtest.txt")
+      
+      # ensure we can overwrite
+      IO.write(test_file, "goodbye cruel world")
+      @communicator.upload(test_file, "c:\\vagrantuploadtest.txt")
+      
+      # get the uploaded file's contents to ensure it uploaded properly
+      uploaded_file_content = ''
+      @communicator.execute("cat c:\\vagrantuploadtest.txt", {}) do |type, line|
+        uploaded_file_content = uploaded_file_content + line
+      end
+      
+      expect(uploaded_file_content.chomp).to eq("goodbye cruel world")
+    end
+  end
 
 end

data/spec/vagrant-windows/winrmfinder_spec.rb

@@ -17,8 +17,7 @@ describe VagrantWindows::Communication::WinRMFinder, :unit => true do
       # setup the winrm config to return nil for the host (i.e. the default)
       winrm_config = VagrantWindows::Config::WinRM.new()
       winrm_config.finalize!()
-      machine_config = stub(:winrm => winrm_config)
-      @machine.stubs(:config).returns(machine_config)
+      @machine.stubs(:winrm_config).returns(winrm_config)
       
       # setup the machine ssh_info to return a 10.0.0.1
       @machine.stubs(:ssh_info).returns({ :host => '10.0.0.1' })
@@ -31,8 +30,7 @@ describe VagrantWindows::Communication::WinRMFinder, :unit => true do
       winrm_config = VagrantWindows::Config::WinRM.new()
       winrm_config.host = '10.0.0.1'
       winrm_config.finalize!()
-      machine_config = stub(:winrm => winrm_config)
-      @machine.stubs(:config).returns(machine_config)
+      @machine.stubs(:winrm_config).returns(winrm_config)
       
       # setup the machine ssh_info to return a 10.0.0.1
       @machine.stubs(:ssh_info).returns({ :host => '127.0.0.1' })

data/spec/vagrant-windows/winrmshell_spec.rb

@@ -5,7 +5,7 @@ describe VagrantWindows::Communication::WinRMShell, :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")
   end
   
   describe "powershell" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-windows
 version: !ruby/object:Gem::Version
-  version: 1.3.0.pre.2
+  version: 1.3.0.pre.3
   prerelease: 6
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-01 00:00:00.000000000 Z
+date: 2013-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: winrm
@@ -163,6 +163,7 @@ files:
 - lib/vagrant-windows/communication/winrmcommunicator.rb
 - lib/vagrant-windows/communication/winrmfinder.rb
 - lib/vagrant-windows/communication/winrmshell.rb
+- lib/vagrant-windows/communication/winrmshell_factory.rb
 - lib/vagrant-windows/config/windows.rb
 - lib/vagrant-windows/config/winrm.rb
 - lib/vagrant-windows/errors.rb
@@ -190,6 +191,7 @@ files:
 - lib/vagrant-windows/scripts/set_work_network.ps1
 - lib/vagrant-windows/scripts/winrs_v3_get_adapters.ps1
 - lib/vagrant-windows/version.rb
+- lib/vagrant-windows/windows_machine.rb
 - lib/vagrant-windows.rb
 - LICENSE
 - locales/en.yml
@@ -200,6 +202,7 @@ files:
 - spec/vagrant-windows/helper_spec.rb
 - spec/vagrant-windows/mount_shared_folder_spec.rb
 - spec/vagrant-windows/windows_config_spec.rb
+- spec/vagrant-windows/windows_machine_spec.rb
 - spec/vagrant-windows/winrm_config_spec.rb
 - spec/vagrant-windows/winrmcommunicator_spec.rb
 - spec/vagrant-windows/winrmfinder_spec.rb
@@ -225,7 +228,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2247683547305016940
+      hash: -432043001542177050
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -245,6 +248,7 @@ test_files:
 - spec/vagrant-windows/helper_spec.rb
 - spec/vagrant-windows/mount_shared_folder_spec.rb
 - spec/vagrant-windows/windows_config_spec.rb
+- spec/vagrant-windows/windows_machine_spec.rb
 - spec/vagrant-windows/winrm_config_spec.rb
 - spec/vagrant-windows/winrmcommunicator_spec.rb
 - spec/vagrant-windows/winrmfinder_spec.rb