vagrant-unbundled 1.9.1.1 → 1.9.5.1

data/plugins/communicators/winrm/communicator.rb

@@ -142,10 +142,10 @@ module VagrantPlugins
           interactive: false,
         }.merge(opts || {})
 
+        opts[:shell] = :elevated if opts[:elevated]
         opts[:good_exit] = Array(opts[:good_exit])
-        command = wrap_in_scheduled_task(command, opts[:interactive]) if opts[:elevated]
         @logger.debug("#{opts[:shell]} executing:\n#{command}")
-        output = shell.send(opts[:shell], command, &block)
+        output = shell.send(opts[:shell], command, opts, &block)
         execution_output(output, opts)
       end
       alias_method :sudo, :execute
@@ -165,7 +165,7 @@ module VagrantPlugins
         # If we're passed a *nix command which PS can't parse we get exit code
         # 0, but output in stderr. We need to check both exit code and stderr.
         output = shell.send(:powershell, command)
-        return output[:exitcode] == 0 && flatten_stderr(output).length == 0
+        return output.exitcode == 0 && output.stderr.length == 0
       end
 
       def upload(from, to)
@@ -180,7 +180,7 @@ module VagrantPlugins
 
       protected
 
-      # This creates anew WinRMShell based on the information we know
+      # This creates a new WinRMShell based on the information we know
       # about this machine.
       def create_shell
         winrm_info = Helper.winrm_info(@machine)
@@ -192,55 +192,23 @@ module VagrantPlugins
         )
       end
 
-      # Creates and uploads a PowerShell script which wraps a command in a
-      # scheduled task. The scheduled task allows commands to run on the guest
-      # as a true local admin without any of the restrictions that WinRM puts
-      # in place.
-      #
-      # @return The wrapper command to execute
-      def wrap_in_scheduled_task(command, interactive)
-        path = File.expand_path("../scripts/elevated_shell.ps1", __FILE__)
-        script = Vagrant::Util::TemplateRenderer.render(path, options: {
-          interactive: interactive,
-        })
-        guest_script_path = "c:/tmp/vagrant-elevated-shell.ps1"
-        Tempfile.open(["vagrant-elevated-shell", "ps1"]) do |f|
-          f.binmode
-          f.write(script)
-          f.fsync
-          f.close
-          upload(f.path, guest_script_path)
-        end
-
-        # Convert to double byte unicode string then base64 encode
-        # just like PowerShell -EncodedCommand expects.
-        # Suppress the progress stream from leaking to stderr.
-        wrapped_encoded_command = Base64.strict_encode64(
-          "$ProgressPreference='SilentlyContinue'; #{command}; exit $LASTEXITCODE".encode('UTF-16LE', 'UTF-8'))
-
-        "powershell -executionpolicy bypass -file '#{guest_script_path}' " +
-          "-username '#{shell.username}' -password '#{shell.password}' " +
-          "-encoded_command '#{wrapped_encoded_command}' " +
-          "-execution_time_limit '#{shell.execution_time_limit}'"
-      end
-
       # Handles the raw WinRM shell result and converts it to a
       # standard Vagrant communicator result
       def execution_output(output, opts)
         if opts[:shell] == :wql
           return output
         elsif opts[:error_check] && \
-          !opts[:good_exit].include?(output[:exitcode])
+          !opts[:good_exit].include?(output.exitcode)
           raise_execution_error(output, opts)
         end
-        output[:exitcode]
+        output.exitcode
       end
 
       def raise_execution_error(output, opts)
         # WinRM can return multiple stderr and stdout entries
         error_opts = opts.merge(
-          stdout: flatten_stdout(output),
-          stderr: flatten_stderr(output)
+          stdout: output.stdout,
+          stderr: output.stderr
         )
 
         # Use a different error message key if the caller gave us one,
@@ -250,20 +218,6 @@ module VagrantPlugins
         # Raise the error, use the type the caller gave us or the comm default
         raise opts[:error_class], error_opts
       end
-
-
-      # TODO: Replace with WinRM Output class when WinRM 1.3 is released
-      def flatten_stderr(output)
-        output[:data].map do | line |
-          line[:stderr]
-        end.compact.join
-      end
-
-      def flatten_stdout(output)
-        output[:data].map do | line |
-          line[:flatten_stdout]
-        end.compact.join
-      end
     end #WinRM class
   end
 end

data/plugins/communicators/winrm/config.rb

@@ -13,6 +13,7 @@ module VagrantPlugins
       attr_accessor :ssl_peer_verification
       attr_accessor :execution_time_limit
       attr_accessor :basic_auth_only
+      attr_accessor :codepage
 
       def initialize
         @username               = UNSET_VALUE
@@ -27,6 +28,7 @@ module VagrantPlugins
         @ssl_peer_verification  = UNSET_VALUE
         @execution_time_limit   = UNSET_VALUE
         @basic_auth_only        = UNSET_VALUE
+        @codepage               = UNSET_VALUE
       end
 
       def finalize!
@@ -43,6 +45,7 @@ module VagrantPlugins
         @ssl_peer_verification = true if @ssl_peer_verification == UNSET_VALUE
         @execution_time_limit = "PT2H"   if @execution_time_limit == UNSET_VALUE
         @basic_auth_only = false    if @basic_auth_only == UNSET_VALUE
+        @codepage = nil        if @codepage == UNSET_VALUE
       end
 
       def validate(machine)

data/plugins/communicators/winrm/helper.rb

@@ -33,7 +33,7 @@ module VagrantPlugins
         return addr if addr
 
         ssh_info = machine.ssh_info
-        raise Errors::WinRMNotReady if !ssh_info
+        raise Errors::WinRMNotReady if !ssh_info || ssh_info[:host].to_s.empty?
         return ssh_info[:host]
       end
 

data/plugins/communicators/winrm/shell.rb

@@ -9,6 +9,7 @@ Vagrant::Util::SilenceWarnings.silence! do
   require "winrm"
 end
 
+require "winrm-elevated"
 require "winrm-fs"
 
 module VagrantPlugins
@@ -53,48 +54,55 @@ module VagrantPlugins
         @config                = config
       end
 
-      def powershell(command, &block)
-        # Ensure an exit code
-        command += "\r\nif ($?) { exit 0 } else { if($LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 } }"
-        session.create_executor do |executor|
-          execute_with_rescue(executor.method("run_powershell_script"), command, &block)
+      def powershell(command, opts = {}, &block)
+        connection.shell(:powershell) do |shell|
+          execute_with_rescue(shell, command, &block)
         end
       end
 
-      def cmd(command, &block)
-        session.create_executor do |executor|
-          execute_with_rescue(executor.method("run_cmd"), command, &block)
+      def cmd(command, opts = {}, &block)
+        shell_opts = {}
+        shell_opts[:codepage] = @config.codepage if @config.codepage
+        connection.shell(:cmd, shell_opts) do |shell|
+          execute_with_rescue(shell, command, &block)
         end
       end
 
-      def wql(query, &block)
+      def elevated(command, opts = {}, &block)
+        connection.shell(:elevated) do |shell|
+          shell.interactive_logon = opts[:interactive] || false
+          execute_with_rescue(shell, command, &block)
+        end
+      end
+
+      def wql(query, opts = {}, &block)
         retryable(tries: @config.max_tries, on: @@exceptions_to_retry_on, sleep: @config.retry_delay) do
-          handle_output(session.method("run_wql"), query, &block)
+          connection.run_wql(query)
         end
       rescue => e
         raise_winrm_exception(e, "run_wql", query)
       end
 
       def upload(from, to)
-        file_manager = WinRM::FS::FileManager.new(session)
+        file_manager = WinRM::FS::FileManager.new(connection)
         file_manager.upload(from, to)
       end
 
       def download(from, to)
-        file_manager = WinRM::FS::FileManager.new(session)
+        file_manager = WinRM::FS::FileManager.new(connection)
         file_manager.download(from, to)
       end
 
       protected
 
-      def execute_with_rescue(method, command, &block)
-        handle_output(method, command, &block)
+      def execute_with_rescue(shell, command, &block)
+        handle_output(shell, command, &block)
       rescue => e
-        raise_winrm_exception(e, method.name, command)
+        raise_winrm_exception(e, shell.class.name.split("::").last, command)
       end
 
-      def handle_output(execute_method, command, &block)
-        output = execute_method.call(command) do |out, err|
+      def handle_output(shell, command, &block)
+        output = shell.run(command) do |out, err|
           block.call(:stdout, out) if block_given? && out
           block.call(:stderr, err) if block_given? && err
         end
@@ -104,14 +112,10 @@ module VagrantPlugins
         # Verify that we didn't get a parser error, and if so we should
         # set the exit code to 1. Parse errors return exit code 0 so we
         # need to do this.
-        if output[:exitcode] == 0
-          (output[:data] || []).each do |data|
-            next if !data[:stderr]
-            if data[:stderr].include?("ParserError")
-              @logger.warn("Detected ParserError, setting exit code to 1")
-              output[:exitcode] = 1
-              break
-            end
+        if output.exitcode == 0
+          if output.stderr.include?("ParserError")
+            @logger.warn("Detected ParserError, setting exit code to 1")
+            output.exitcode = 1
           end
         end
 
@@ -159,21 +163,20 @@ module VagrantPlugins
         end
       end
 
-      def new_session
+      def new_connection
         @logger.info("Attempting to connect to WinRM...")
         @logger.info("  - Host: #{@host}")
         @logger.info("  - Port: #{@port}")
         @logger.info("  - Username: #{@config.username}")
         @logger.info("  - Transport: #{@config.transport}")
 
-        client = ::WinRM::WinRMWebService.new(endpoint, @config.transport.to_sym, endpoint_options)
-        client.set_timeout(@config.timeout)
+        client = ::WinRM::Connection.new(endpoint_options)
         client.logger = @logger
         client
       end
 
-      def session
-        @session ||= new_session
+      def connection
+        @connection ||= new_connection
       end
 
       def endpoint
@@ -188,8 +191,11 @@ module VagrantPlugins
       end
 
       def endpoint_options
-        { user: @username,
-          pass: @password,
+        { endpoint: endpoint,
+          transport: @config.transport,
+          operation_timeout: @config.timeout,
+          user: @username,
+          password: @password,
           host: @host,
           port: @port,
           basic_auth_only: @config.basic_auth_only,

data/plugins/communicators/winssh/communicator.rb

@@ -0,0 +1,161 @@
+require File.expand_path("../../ssh/communicator", __FILE__)
+
+module VagrantPlugins
+  module CommunicatorWinSSH
+    # This class provides communication with a Windows VM running
+    # the Windows native port of OpenSSH
+    class Communicator < VagrantPlugins::CommunicatorSSH::Communicator
+
+      def initialize(machine)
+        super
+        @logger = Log4r::Logger.new("vagrant::communication::winssh")
+      end
+
+      # Executes the command on an SSH connection within a login shell.
+      def shell_execute(connection, command, **opts)
+        opts = {
+          sudo: false,
+          shell: nil
+        }.merge(opts)
+
+        sudo  = opts[:sudo]
+        shell = (opts[:shell] || machine_config_ssh.shell).to_s
+
+        @logger.info("Execute: #{command} (sudo=#{sudo.inspect})")
+        exit_status = nil
+
+        # Open the channel so we can execute or command
+        channel = connection.open_channel do |ch|
+          marker_found = false
+          data_buffer = ''
+          stderr_marker_found = false
+          stderr_data_buffer = ''
+
+          tfile = Tempfile.new('vagrant-ssh')
+          remote_ext = shell == "powershell" ? "ps1" : "bat"
+          remote_name = "C:\\Windows\\Temp\\#{File.basename(tfile.path)}.#{remote_ext}"
+
+          if shell == "powershell"
+            base_cmd = "powershell -File #{remote_name}"
+            tfile.puts <<-SCRIPT.force_encoding('ASCII-8BIT')
+Remove-Item #{remote_name}
+Write-Host #{CMD_GARBAGE_MARKER}
+[Console]::Error.WriteLine("#{CMD_GARBAGE_MARKER}")
+#{command}
+SCRIPT
+          else
+            base_cmd = remote_name
+            tfile.puts <<-SCRIPT.force_encoding('ASCII-8BIT')
+ECHO OFF
+ECHO #{CMD_GARBAGE_MARKER}
+ECHO #{CMD_GARBAGE_MARKER} 1>&2
+#{command}
+SCRIPT
+          end
+
+          tfile.close
+          upload(tfile.path, remote_name)
+          tfile.delete
+
+          base_cmd = shell_cmd(opts.merge(shell: base_cmd))
+          @logger.debug("Base SSH exec command: #{base_cmd}")
+
+          ch.exec(base_cmd) do |ch2, _|
+            # Setup the channel callbacks so we can get data and exit status
+            ch2.on_data do |ch3, data|
+              # Filter out the clear screen command
+              data = remove_ansi_escape_codes(data)
+
+              if !marker_found
+                data_buffer << data
+                marker_index = data_buffer.index(CMD_GARBAGE_MARKER)
+                if marker_index
+                  marker_found = true
+                  data_buffer.slice!(0, marker_index + CMD_GARBAGE_MARKER.size)
+                  data.replace(data_buffer)
+                  data_buffer = nil
+                end
+              end
+
+              if block_given? && marker_found
+                yield :stdout, data
+              end
+            end
+
+            ch2.on_extended_data do |ch3, type, data|
+              # Filter out the clear screen command
+              data = remove_ansi_escape_codes(data)
+              @logger.debug("stderr: #{data}")
+              if !stderr_marker_found
+                stderr_data_buffer << data
+                marker_index = stderr_data_buffer.index(CMD_GARBAGE_MARKER)
+                if marker_index
+                  marker_found = true
+                  stderr_data_buffer.slice!(0, marker_index + CMD_GARBAGE_MARKER.size)
+                  data.replace(stderr_data_buffer.lstrip)
+                  data_buffer = nil
+                end
+              end
+
+              if block_given? && marker_found
+                yield :stderr, data
+              end
+            end
+
+            ch2.on_request("exit-status") do |ch3, data|
+              exit_status = data.read_long
+              @logger.debug("Exit status: #{exit_status}")
+
+              # Close the channel, since after the exit status we're
+              # probably done. This fixes up issues with hanging.
+              ch.close
+            end
+
+          end
+        end
+
+        begin
+          keep_alive = nil
+
+          if @machine.config.ssh.keep_alive
+            # Begin sending keep-alive packets while we wait for the script
+            # to complete. This avoids connections closing on long-running
+            # scripts.
+            keep_alive = Thread.new do
+              loop do
+                sleep 5
+                @logger.debug("Sending SSH keep-alive...")
+                connection.send_global_request("keep-alive@openssh.com")
+              end
+            end
+          end
+
+          # Wait for the channel to complete
+          begin
+            channel.wait
+          rescue Errno::ECONNRESET, IOError
+            @logger.info(
+              "SSH connection unexpected closed. Assuming reboot or something.")
+            exit_status = 0
+            pty = false
+          rescue Net::SSH::ChannelOpenFailed
+            raise Vagrant::Errors::SSHChannelOpenFail
+          rescue Net::SSH::Disconnect
+            raise Vagrant::Errors::SSHDisconnected
+          end
+        ensure
+          # Kill the keep-alive thread
+          keep_alive.kill if keep_alive
+        end
+
+        # Return the final exit status
+        return exit_status
+      end
+
+      def machine_config_ssh
+        @machine.config.winssh
+      end
+
+    end
+  end
+end

data/plugins/communicators/winssh/config.rb

@@ -0,0 +1,30 @@
+require File.expand_path("../../../kernel_v2/config/ssh", __FILE__)
+
+module VagrantPlugins
+  module CommunicatorWinSSH
+    class Config < VagrantPlugins::Kernel_V2::SSHConfig
+
+      def finalize!
+        @shell = "cmd" if @shell == UNSET_VALUE
+        @sudo_command = "%c" if @sudo_command == UNSET_VALUE
+        if @export_command_template == UNSET_VALUE
+          if @shell == "cmd"
+            @export_command_template = 'set %ENV_KEY%="%ENV_VALUE%"'
+          else
+            @export_command_template = '$env:%ENV_KEY%="%ENV_VALUE%"'
+          end
+        end
+        super
+      end
+
+      def to_s
+        "WINSSH"
+      end
+
+      # Remove configuration options from regular SSH that are
+      # not used within this communicator
+      undef :forward_x11
+      undef :pty
+    end
+  end
+end