vagrant-windows 1.6.0 → 1.7.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e89e485b8fae09a9d784792b184ebbc61d70185
-  data.tar.gz: a36e78c2c59df8921a7ad3db46ac7713d02a04d7
+  metadata.gz: 9e0d8f67d7fd5775bc1dfffb01aee0f766c5c512
+  data.tar.gz: fd24bde9a3b09754acb450f2995a61c0292a7294
 SHA512:
-  metadata.gz: 035e50bbe58c5e2512624982e1a2797f36530ce8855c67e45dbd5ab3aea8d15390aab866b870c660a870799061cdcec33f006f610928812ee4cb747685a5901d
-  data.tar.gz: a23744a7c72a969c0ea40a935b1a5deb8c85bafc0a4815f4729d232c7f74a7a12ea0283156b88499740b175d6085e702d69b80a66ad129e873e72c059a868c80
+  metadata.gz: 081a4d22f0f528b6672009678de4c7558c24059036a62c5d8e595073de8cc4566c38f72c78bacd3a67d5a9da6b2a2b8d96a356dc26b391adf8bb59c11a75ec57
+  data.tar.gz: c11a66f853413fc9ca9970ce767c1a71ddd3c0193766a9cf7980b9aeb5af67dfff414720e1ea3e4116b0072925353bd780d300bbe94ab75f59372b23319f1d8e

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/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,14 +47,20 @@ 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)
+        if (win_friendly_cmd.empty?)
+          return { :exitcode => 0, :stderr => '', :stdout => '' }
+        end
+
         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)
+        exit_status = do_execute(win_friendly_cmd, opts[:shell], &block)
         if opts[:error_check] && exit_status != 0
           raise_execution_error(opts, exit_status)
         end
@@ -61,22 +69,21 @@ module VagrantWindows
       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)
+        if (win_friendly_cmd.empty?)
+          return false
+        end
 
         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,7 +94,7 @@ module VagrantWindows
       def winrmshell
         @winrmshell ||= @winrm_shell_factory.create_winrm_shell()
       end
-      
+
       
       protected
       
@@ -95,7 +102,7 @@ module VagrantWindows
         if shell.eql? :cmd
           winrmshell.cmd(command, &block)[:exitcode]
         else
-          command = VagrantWindows.load_script("command_alias.ps1") << "\r\n" << command << "\r\nexit $LASTEXITCODE"
+          command << "\r\nexit $LASTEXITCODE"
           winrmshell.powershell(command, &block)[:exitcode]
         end
       end

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

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

@@ -56,35 +56,16 @@ 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
+        WinRMFileManager.new(self).upload(from, to)
       end
 
       def download(from, to)
-        @logger.debug("Downloading: #{from} to #{to}")
-        output = powershell("[System.convert]::ToBase64String([System.IO.File]::ReadAllBytes(\"#{from}\"))")
-        contents = output[:data].map!{|line| line[:stdout]}.join.gsub("\\n\\r", '')
-        out = Base64.decode64(contents)
-        IO.binwrite(to, out)
+        WinRMFileManager.new(self).download(from, to)
       end
 
+
       protected
       
       def execute_shell(command, shell=:powershell, &block)

data/lib/vagrant-windows/errors.rb

@@ -21,7 +21,11 @@ module VagrantWindows
     
     class WinRMAuthorizationError < VagrantWindowsError
       error_key(:winrm_auth_error)
-    end    
+    end
+
+    class WinRMFileTransferError < VagrantWindowsError
+      error_key(:winrm_file_transfer_error)
+    end
 
   end
 end

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

@@ -34,11 +34,8 @@ module VagrantPlugins
           end
 
           #################### START - monkey patched code ####################
-          command_builder = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
-            @windows_machine, @config, :client)
-          
-          command_builder.prepare_for_chef_run()
-          command = command_builder.run_chef_command()
+          command = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
+            @windows_machine, @config, :client).run_chef_command()
           ###################### END - monkey patched code ####################
 
           @config.attempts.times do |attempt|

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

@@ -32,11 +32,8 @@ module VagrantPlugins
         def run_chef_solo_on_windows
           
           #################### START - monkey patched code ####################
-          command_builder = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
-            @windows_machine, @config, :solo)
-          
-          command_builder.prepare_for_chef_run()
-          command = command_builder.run_chef_command()
+          command = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
+            @windows_machine, @config, :solo).run_chef_command()
           ###################### END - monkey patched code ####################
 
           @config.attempts.times do |attempt|

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

@@ -34,12 +34,19 @@ module VagrantPlugins
               end
               comm.upload(path.to_s, fixed_upload_path)
 
-              command = <<-EOH
-              $old = Get-ExecutionPolicy;
-              Set-ExecutionPolicy Unrestricted -force;
-              #{win_friendly_path(fixed_upload_path)}#{args};
-              Set-ExecutionPolicy $old -force
-              EOH
+              # if powershell script we need to bypass the execution policy
+              command = "#{win_friendly_path(fixed_upload_path)}#{args}"
+              command = "powershell -executionpolicy bypass -file #{command}" if
+                File.extname(fixed_upload_path).downcase == '.ps1'
+
+              # for priviliged scripts we need wrap it in a scheduled task
+              if config.privileged
+                command = VagrantWindows.load_script_template('elevated_shell.ps1', :options => {
+                  :command => command,
+                  :username => windows_machine.winrm_config.username,
+                  :password => windows_machine.winrm_config.password
+                })
+              end
               
               # Execute it with sudo
               comm.sudo(command) do |type, data|