vagrant-windows 1.6.0 → 1.7.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e89e485b8fae09a9d784792b184ebbc61d70185
-  data.tar.gz: a36e78c2c59df8921a7ad3db46ac7713d02a04d7
+  metadata.gz: 668a6e4a7bc645fa0e951e3f04a33257e4eb5890
+  data.tar.gz: e080e229467c6a45f6d3ae5a180e1c8b4ed92528
 SHA512:
-  metadata.gz: 035e50bbe58c5e2512624982e1a2797f36530ce8855c67e45dbd5ab3aea8d15390aab866b870c660a870799061cdcec33f006f610928812ee4cb747685a5901d
-  data.tar.gz: a23744a7c72a969c0ea40a935b1a5deb8c85bafc0a4815f4729d232c7f74a7a12ea0283156b88499740b175d6085e702d69b80a66ad129e873e72c059a868c80
+  metadata.gz: 77c523c5c5bd2a464cb4cabc5ce613f31ec4ab7f76c8765fffdc79fffd9175b90dfd59cd19cac4cdc4c3527cf5ba7392b7933e29cbcfaed50702b998c81761e2
+  data.tar.gz: d2b1f5f4198cdaa1e3b88480b95e69d8af18ce4f01d55836ee7a361e488a4168e821b7b9d336857b8165dca7163b6b0e57e0c63483115d7881dc0076cec33836

data/.travis.yml

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

data/CHANGELOG.md

@@ -76,4 +76,10 @@
 
 1.6.0
 - Added chef-client provisioner support and extracted shared code from chef-solo provisioner
-- WinRM communicator download support
+- WinRM communicator download support
+
+1.7.0
+- Added recursive directory upload on communicator, similar to core Vagrant SCP functionality.
+- Redesigned elevated command execution in Chef to make it reusable
+- Shell provisioner now runs elevated by default unless privileged is false
+- Removed *nix command alias PS script and created extensible linux command filter system

data/Gemfile

@@ -7,6 +7,10 @@ group :development do
   # We depend on Vagrant for development, but we don't add it as a
   # gem dependency because we expect to be installed within the
   # Vagrant environment itself using `vagrant plugin`.
-  gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git", :tag => 'v1.4.0'
+  gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git", :tag => 'v1.5.2'
   gem "mocha", :require => false
 end
+
+group :plugins do
+  gem "vagrant-windows", path: '.'
+end

data/README.md

@@ -13,7 +13,9 @@ This [Vagrant](http://www.vagrantup.com/) plugin allows you to standup Windows g
 
 ## Installation
 
-- For Vagrant 1.1 and above execute `vagrant plugin install vagrant-windows`.
+Vagrant 1.6 will natively support Windows guests, this plugin should not be used with Vagrant 1.6 or later.
+
+- For Vagrant 1.1 -> 1.5 execute `vagrant plugin install vagrant-windows`.
 - For Vagrant 1.0 execute `vagrant plugin install vagrant-windows --plugin-version 0.1.2`.
 
 ## Creating a Base Box

data/lib/vagrant-windows/communication/command_filters/cat.rb

@@ -0,0 +1,27 @@
+module VagrantWindows
+  module Communication
+    module CommandFilters
+
+      # Handles the special case of determining the guest OS using cat
+      class Cat
+
+        def filter(command)
+          # cat /etc/release | grep -i OmniOS
+          # cat /etc/redhat-release
+          # cat /etc/issue | grep 'Core Linux'
+          # cat /etc/release | grep -i SmartOS
+          ''
+        end
+
+        def accept?(command)
+          # cat works in PowerShell, however we don't want to run Guest
+          # OS detection as this will fail on Windows because the lack of the
+          # grep command
+          command.start_with?('cat /etc/')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/vagrant-windows/communication/command_filters/chmod.rb

@@ -0,0 +1,21 @@
+module VagrantWindows
+  module Communication
+    module CommandFilters
+
+      # Converts a *nix 'chmod' command to a PowerShell equivalent
+      class Chmod
+
+        def filter(command)
+          # Not support on Windows, the communicator will skip this command
+          ''
+        end
+
+        def accept?(command)
+          command.start_with?('chmod ')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/vagrant-windows/communication/command_filters/chown.rb

@@ -0,0 +1,21 @@
+module VagrantWindows
+  module Communication
+    module CommandFilters
+
+      # Converts a *nix 'chown' command to a PowerShell equivalent
+      class Chown
+
+        def filter(command)
+          # Not support on Windows, the communicator will skip this command
+          ''
+        end
+
+        def accept?(command)
+          command.start_with?('chown ')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/vagrant-windows/communication/command_filters/rm.rb

@@ -0,0 +1,28 @@
+module VagrantWindows
+  module Communication
+    module CommandFilters
+
+      # Converts a *nix 'rm' command to a PowerShell equivalent
+      class Rm
+
+        def filter(command)
+          # rm -Rf /some/dir
+          # rm /some/dir
+          cmd_parts = command.strip.split(/\s+/)
+          dir = cmd_parts[1]
+          if dir == '-Rf'
+            dir = cmd_parts[2]
+            return "rm '#{dir}' -recurse -force"
+          end
+          return "rm '#{dir}' -force"
+        end
+
+        def accept?(command)
+          command.start_with?('rm ')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/vagrant-windows/communication/command_filters/test.rb

@@ -0,0 +1,37 @@
+module VagrantWindows
+  module Communication
+    module CommandFilters
+
+      # Converts a *nix 'test' command to a PowerShell equivalent
+      class Test
+
+        def filter(command)
+          # test -d /tmp/dir
+          # test -f /tmp/afile
+          # test -L /somelink
+          # test -x /tmp/some.exe
+          
+          cmd_parts = command.strip.split(/\s+/)
+          if cmd_parts[1] == '-d'
+            # ensure it exists and is a directory
+            return "if ((Test-Path '#{cmd_parts[2]}') -and (get-item '#{cmd_parts[2]}').PSIsContainer) { exit 0 } exit 1"
+          elsif cmd_parts[1] == '-f' || cmd_parts[1] == '-x'
+            # ensure it exists and is a file
+            return "if ((Test-Path '#{cmd_parts[2]}') -and (!(get-item '#{cmd_parts[2]}').PSIsContainer)) { exit 0 } exit 1"
+          end
+
+          # otherwise, just check for existence
+          return "if (Test-Path '#{cmd_parts[2]}') { exit 0 } exit 1"
+        end
+
+        # if (Test-Path 'c:\windows' && (get-item 'c:\windows').PSIsContainer) { Write-Host 0 } Write-Host 1
+
+        def accept?(command)
+          command.start_with?('test ')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/vagrant-windows/communication/command_filters/uname.rb

@@ -0,0 +1,36 @@
+# cat /etc/release | grep -i OmniOS
+# cat /etc/redhat-release
+# cat /etc/issue | grep 'Core Linux'
+# cat /etc/release | grep -i SmartOS
+
+module VagrantWindows
+  module Communication
+    module CommandFilters
+
+      # Converts a *nix 'uname' command to a PowerShell equivalent
+      class Uname
+
+        def filter(command)
+          # uname -s | grep 'Darwin'
+          # uname -s | grep VMkernel
+          # uname -s | grep 'FreeBSD'
+          # uname -s | grep 'Linux'
+          # uname -s | grep NetBSD
+          # uname -s | grep 'OpenBSD'
+          # uname -sr | grep SunOS | grep -v 5.11
+          # uname -sr | grep 'SunOS 5.11'
+
+          # uname is used to detect the guest type in Vagrant, so don't bother running
+          # to speed up OS detection
+          ''
+        end
+
+        def accept?(command)
+          command.start_with?('uname ')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/vagrant-windows/communication/command_filters/which.rb

@@ -0,0 +1,26 @@
+module VagrantWindows
+  module Communication
+    module CommandFilters
+
+      # Converts a *nix 'which' command to a PowerShell equivalent
+      class Which
+
+        def filter(command)
+          executable = command.strip.split(/\s+/)[1]
+          return <<-EOH
+            $command = [Array](Get-Command #{executable} -errorAction SilentlyContinue)
+            if ($null -eq $command) { exit 1 }
+            write-host $command[0].Definition
+            exit 0
+          EOH
+        end
+
+        def accept?(command)
+          command.start_with?('which ')
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -12,13 +12,10 @@ module VagrantWindows
       PS_GET_WSMAN_VER = '((test-wsman).productversion.split(" ") | select -last 1).split("\.")[0]'
       WQL_NET_ADAPTERS_V2 = 'SELECT * FROM Win32_NetworkAdapter WHERE MACAddress IS NOT NULL'
 
-      attr_reader :logger
-      attr_reader :winrmshell
-
-      def initialize(winrmshell)
-        @logger = Log4r::Logger.new("vagrant_windows::communication::winrmshell")
+      def initialize(communicator)
+        @logger = Log4r::Logger.new("vagrant_windows::communication::guestnetwork")
         @logger.debug("initializing WinRMShell")
-        @winrmshell = winrmshell
+        @communicator = communicator
       end
       
       # Returns an array of all NICs on the guest. Each array entry is a
@@ -33,13 +30,13 @@ module VagrantWindows
       #
       # @return [Boolean]
       def is_dhcp_enabled(nic_index)
-        has_dhcp_enabled = false
-        cmd = "Get-WmiObject -Class Win32_NetworkAdapterConfiguration -Filter \"Index=#{nic_index} and DHCPEnabled=True\""
-        @winrmshell.powershell(cmd) do |type, line|
-          has_dhcp_enabled = !line.nil?
-        end
-        @logger.debug("NIC #{nic_index} has DHCP enabled: #{has_dhcp_enabled}")
-        has_dhcp_enabled
+        cmd = <<-EOH
+          if (Get-WmiObject -Class Win32_NetworkAdapterConfiguration -Filter "Index=#{nic_index} and DHCPEnabled=True") {
+            exit 0
+          }
+          exit 1
+        EOH
+        @communicator.test(cmd)
       end
       
       # Configures the specified interface for DHCP
@@ -50,7 +47,7 @@ module VagrantWindows
         @logger.info("Configuring NIC #{net_connection_id} for DHCP")
         if !is_dhcp_enabled(nic_index)
           netsh = "netsh interface ip set address \"#{net_connection_id}\" dhcp"
-          @winrmshell.powershell(netsh)
+          @communicator.execute(netsh)
         end
       end
       
@@ -64,7 +61,7 @@ module VagrantWindows
         @logger.info("Configuring NIC #{net_connection_id} using static ip #{ip}")
         #netsh interface ip set address "Local Area Connection 2" static 192.168.33.10 255.255.255.0
         netsh = "netsh interface ip set address \"#{net_connection_id}\" static #{ip} #{netmask}"
-        @winrmshell.powershell(netsh)
+        @communicator.execute(netsh)
       end
       
       # Sets all networks on the guest to 'Work Network' mode. This is
@@ -73,7 +70,7 @@ module VagrantWindows
       def set_all_networks_to_work()
         @logger.info("Setting all networks to 'Work Network'")
         command = VagrantWindows.load_script("set_work_network.ps1")
-        @winrmshell.powershell(command)
+        @communicator.execute(command)
       end
       
 
@@ -86,7 +83,7 @@ module VagrantWindows
       def wsman_version()
         @logger.debug("querying WSMan version")
         version = ''
-        @winrmshell.powershell(PS_GET_WSMAN_VER) do |type, line|
+        @communicator.execute(PS_GET_WSMAN_VER) do |type, line|
           version = version + "#{line}" if type == :stdout && !line.nil?
         end
         @logger.debug("wsman version: #{version}")
@@ -102,7 +99,7 @@ module VagrantWindows
         @logger.debug("querying network adapters")
         # Get all NICs that have a MAC address
         # http://msdn.microsoft.com/en-us/library/windows/desktop/aa394216(v=vs.85).aspx
-        adapters = @winrmshell.wql(WQL_NET_ADAPTERS_V2)[:win32_network_adapter]
+        adapters = @communicator.execute(WQL_NET_ADAPTERS_V2, { :shell => :wql } )[:win32_network_adapter]
         @logger.debug("#{adapters.inspect}")
         return adapters
       end
@@ -117,7 +114,7 @@ module VagrantWindows
       def network_adapters_v3_winrm()
         winrs_v3_get_adapters_ps1 = VagrantWindows.load_script("winrs_v3_get_adapters.ps1")
         output = ''
-        @winrmshell.powershell(winrs_v3_get_adapters_ps1) do |type, line|
+        @communicator.execute(winrs_v3_get_adapters_ps1) do |type, line|
           output = output + "#{line}" if type == :stdout && !line.nil?
         end
         adapters = []

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

@@ -0,0 +1,44 @@
+module VagrantWindows
+  module Communication
+   
+    # Handles loading all available Linix command filters and applying them
+    # to specified command
+    class LinuxCommandFilter
+
+      # Filter the given Vagrant command to ensure compatibility with Windows
+      #
+      # @param [String] The Vagrant shell command
+      # @returns [String] Windows runnable command or empty string
+      def filter(command)
+        win_friendly_cmd = command
+        command_filters.each do |cmd_filter|
+          win_friendly_cmd = cmd_filter.filter(win_friendly_cmd) if cmd_filter.accept?(win_friendly_cmd)
+        end
+        win_friendly_cmd
+      end
+
+
+      # All the available Linux command filters
+      #
+      # @returns [Array] All Linux command filter instances
+      def command_filters
+        @command_filters ||= create_command_filters()
+      end
+
+      # Creates all the available Linux command filters
+      #
+      # @returns [Array] All Linux command filter instances
+      def create_command_filters
+        filters = []
+        Dir[File.join(File.dirname(__FILE__), '/command_filters/*.rb')].each do |file|
+          require file
+          clazz = File.basename(file, '.*').capitalize
+          filters << Module.const_get("VagrantWindows::Communication::CommandFilters::#{clazz}").new
+        end
+        filters
+      end
+
+    end
+
+  end
+end

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

@@ -2,7 +2,9 @@ require 'timeout'
 require 'log4r'
 require_relative 'winrmshell_factory'
 require_relative 'winrmshell'
+require_relative 'winrmfilemanager'
 require_relative 'winrmfinder'
+require_relative 'linux_command_filter'
 require_relative '../errors'
 require_relative '../windows_machine'
 
@@ -18,7 +20,7 @@ module VagrantWindows
       def initialize(machine)
         @windows_machine = VagrantWindows::WindowsMachine.new(machine)
         @winrm_shell_factory = WinRMShellFactory.new(@windows_machine, WinRMFinder.new(@windows_machine))
-
+        @linux_cmd_filter = LinuxCommandFilter.new()
         @logger = Log4r::Logger.new("vagrant_windows::communication::winrmcommunicator")
         @logger.debug("initializing WinRMCommunicator")
       end
@@ -45,38 +47,42 @@ module VagrantWindows
       end
       
       def execute(command, opts={}, &block)
+        # If this is a *nix command with no Windows equivilant, don't run it
+        win_friendly_cmd = @linux_cmd_filter.filter(command)
+        return 0 if win_friendly_cmd.empty?
+
         opts = {
           :error_check => true,
           :error_class => VagrantWindows::Errors::WinRMExecutionError,
           :error_key   => :winrm_execution_error,
-          :command     => command,
+          :command     => win_friendly_cmd,
           :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
+
+        win_friendly_cmd << "\r\nexit $LASTEXITCODE" if opts[:shell] == :powershell
+        output = winrmshell.send(opts[:shell], win_friendly_cmd, &block)
+
+        return output if opts[:shell] == :wql
+        exitcode = output[:exitcode]
+        raise_execution_error(opts, exitcode) if opts[:error_check] && exitcode != 0
+        exitcode
       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?
+        # If this is a *nix command with no Windows equivilant, don't run it
+        win_friendly_cmd = @linux_cmd_filter.filter(command)
+        return false if win_friendly_cmd.empty?
 
         opts = { :error_check => false }.merge(opts || {})
-        execute(command, opts) == 0
+        execute(win_friendly_cmd, opts) == 0
       end
 
       def upload(from, to)
-        @logger.debug("Uploading: #{from} to #{to}")
         winrmshell.upload(from, to)
       end
       
       def download(from, to)
-        @logger.debug("Downloading: #{from} to #{to}")
         winrmshell.download(from, to)
       end
       
@@ -87,19 +93,10 @@ module VagrantWindows
       def winrmshell
         @winrmshell ||= @winrm_shell_factory.create_winrm_shell()
       end
-      
+
       
       protected
       
-      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`

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

@@ -0,0 +1,166 @@
+require 'log4r'
+require 'winrm'
+require_relative 'winrmshell'
+require_relative '../errors'
+
+module VagrantWindows
+  module Communication
+
+    # Manages the file system on the remote guest allowing for file tranfer
+    # between the guest and host.
+    class WinRMFileManager
+
+      def initialize(winrm_shell)
+        @logger = Log4r::Logger.new("vagrant_windows::communication::winrmfilemanager")
+        @winrm_shell = winrm_shell
+      end
+      
+      # Uploads the given file or directory from the host to the guest (recursively).
+      #
+      # @param [String] The source file or directory path on the host
+      # @param [String] The destination file or directory path on the host
+      def upload(host_src_file_path, guest_dest_file_path)
+        @logger.debug("Upload: #{host_src_file_path} -> #{guest_dest_file_path}")
+        if File.directory?(host_src_file_path)
+          upload_directory(host_src_file_path, guest_dest_file_path)
+        else
+          upload_file(host_src_file_path, guest_dest_file_path)
+        end
+      end
+
+      # Downloads the given file from the guest to the host.
+      # NOTE: This currently only supports single file download
+      #
+      # @param [String] The source file path on the guest
+      # @param [String] The destination file path on the host
+      def download(guest_src_file_path, host_dest_file_path)
+        @logger.debug("#{guest_src_file_path} -> #{host_dest_file_path}")
+        output = @winrm_shell.powershell("[System.convert]::ToBase64String([System.IO.File]::ReadAllBytes(\"#{guest_src_file_path}\"))")
+        contents = output[:data].map!{|line| line[:stdout]}.join.gsub("\\n\\r", '')
+        out = Base64.decode64(contents)
+        IO.binwrite(host_dest_file_path, out)
+      end
+
+
+      private
+
+      # Recursively uploads the given directory from the host to the guest
+      #
+      # @param [String] The source file or directory path on the host
+      # @param [String] The destination file or directory path on the host
+      def upload_directory(host_src_file_path, guest_dest_file_path)
+        glob_patt = File.join(host_src_file_path, '**/*')
+        Dir.glob(glob_patt).select { |f| !File.directory?(f) }.each do |host_file_path|
+          guest_file_path = guest_file_path(host_src_file_path, guest_dest_file_path, host_file_path)
+          upload_file(host_file_path, guest_file_path)
+        end
+      end
+
+      # Uploads the given file, but only if the target file doesn't exist
+      # or its MD5 checksum doens't match the host's source checksum.
+      #
+      # @param [String] The source file path on the host
+      # @param [String] The destination file path on the guest
+      def upload_file(host_src_file_path, guest_dest_file_path)
+        if should_upload_file?(host_src_file_path, guest_dest_file_path)
+          tmp_file_path = upload_to_temp_file(host_src_file_path)
+          decode_temp_file(tmp_file_path, guest_dest_file_path)
+        else
+          @logger.debug("Up to date: #{guest_dest_file_path}")
+        end
+      end
+
+      # Uploads the given file to a new temp file on the guest
+      #
+      # @param [String] The source file path on the host
+      # @return [String] The temp file path on the guest
+      def upload_to_temp_file(host_src_file_path)
+        tmp_file_path = File.join(guest_temp_dir, "winrm-upload-#{rand()}")
+        @logger.debug("Uploading '#{host_src_file_path}' to temp file '#{tmp_file_path}'")
+        base64_host_file = Base64.encode64(IO.binread(host_src_file_path)).gsub("\n",'')
+        base64_host_file.chars.to_a.each_slice(8000-tmp_file_path.size) do |chunk|
+          out = @winrm_shell.cmd("echo #{chunk.join} >> \"#{tmp_file_path}\"")
+          raise_upload_error_if_failed(out, host_src_file_path, tmp_file_path)
+        end
+        tmp_file_path
+      end
+
+      # Moves and decodes the given file temp file on the guest to its
+      # permanent location
+      #
+      # @param [String] The source base64 encoded temp file path on the guest
+      # @param [String] The destination file path on the guest
+      def decode_temp_file(guest_tmp_file_path, guest_dest_file_path)
+        @logger.debug("Decoding temp file '#{guest_tmp_file_path}' to '#{guest_dest_file_path}'")
+        out = @winrm_shell.powershell <<-EOH
+          $tmp_file_path = [System.IO.Path]::GetFullPath('#{guest_tmp_file_path}')
+          $dest_file_path = [System.IO.Path]::GetFullPath('#{guest_dest_file_path}')
+
+          if (Test-Path $dest_file_path) {
+            rm $dest_file_path
+          }
+          else {
+            $dest_dir = ([System.IO.Path]::GetDirectoryName($dest_file_path))
+            New-Item -ItemType directory -Force -Path $dest_dir
+          }
+
+          $base64_string = Get-Content $tmp_file_path
+          $bytes = [System.Convert]::FromBase64String($base64_string) 
+          [System.IO.File]::WriteAllBytes($dest_file_path, $bytes)
+        EOH
+        raise_upload_error_if_failed(out, guest_tmp_file_path, guest_dest_file_path)
+      end
+
+      # Checks to see if the target file on the guest is missing or out of date.
+      #
+      # @param [String] The source file path on the host
+      # @param [String] The destination file path on the guest
+      # @return [Boolean] True if the file is missing or out of date
+      def should_upload_file?(host_src_file_path, guest_dest_file_path)
+        local_md5 = Digest::MD5.file(host_src_file_path).hexdigest
+        cmd = <<-EOH
+          $dest_file_path = [System.IO.Path]::GetFullPath('#{guest_dest_file_path}')
+
+          if (Test-Path $dest_file_path) {
+            $crypto_provider = new-object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
+            try {
+              $file = [System.IO.File]::Open($dest_file_path, [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read)
+              $guest_md5 = ([System.BitConverter]::ToString($crypto_provider.ComputeHash($file))).Replace("-","").ToLower()
+            }
+            finally {
+              $file.Dispose()
+            }
+            if ($guest_md5 -eq '#{local_md5}') {
+              exit 0
+            }
+          }
+          exit 1
+        EOH
+        @winrm_shell.powershell(cmd)[:exitcode] == 1
+      end
+
+      # Creates a guest file path equivalent from a host file path
+      #
+      # @param [String] The base host directory we're going to copy from
+      # @param [String] The base guest directory we're going to copy to
+      # @param [String] A full path to a file on the host underneath host_base_dir
+      # @return [String] The guest file path equivalent
+      def guest_file_path(host_base_dir, guest_base_dir, host_file_path)
+        rel_path = File.dirname(host_file_path[host_base_dir.length, host_file_path.length])
+        File.join(guest_base_dir, rel_path, File.basename(host_file_path))
+      end
+
+      def guest_temp_dir
+        @guest_temp ||= (@winrm_shell.cmd('echo %TEMP%'))[:data][0][:stdout].chomp
+      end
+
+      def raise_upload_error_if_failed(out, from, to)
+        raise Errors::WinRMFileTransferError,
+          :from => from,
+          :to => to,
+          :message => out.inspect if out[:exitcode] != 0
+      end
+    
+    end #class
+  end
+end