vagrant-aws-mkubenka 0.7.2.pre.22 → 0.7.2.pre.24

data/vendor/bundle/ruby/2.7.0/bundler/gems/vagrant-22795b161bf6/plugins/communicators/winrm/helper.rb

@@ -0,0 +1,88 @@
+module VagrantPlugins
+  module CommunicatorWinRM
+    # This is a helper module that provides some functions to the
+    # communicator. This is extracted into a module so that we can
+    # easily unit test these methods.
+    module Helper
+      # Returns the host and port to access WinRM.
+      #
+      # This asks the provider via the `winrm_info` capability if it
+      # exists, otherwise defaulting to its own heuristics.
+      #
+      # @param [Vagrant::Machine] machine
+      # @return [Hash]
+      def self.winrm_info(machine)
+        info = {}
+        if machine.provider.capability?(:winrm_info)
+          info = machine.provider.capability(:winrm_info)
+          raise Errors::WinRMNotReady if !info
+        end
+
+        info[:host] ||= winrm_address(machine)
+        info[:port] ||= winrm_port(machine, info[:host] == "127.0.0.1")
+        return info
+      end
+
+      # Returns the address to access WinRM. This does not contain
+      # the port.
+      #
+      # @param [Vagrant::Machine] machine
+      # @return [String]
+      def self.winrm_address(machine)
+        addr = machine.config.winrm.host
+        return addr if addr
+
+        ssh_info = machine.ssh_info
+        raise Errors::WinRMNotReady if winrm_info_invalid?(ssh_info)
+        return ssh_info[:host]
+      end
+
+      def self.winrm_info_invalid?(ssh_info)
+        invalid = (!ssh_info || ssh_info[:host].to_s.empty? || ssh_info[:host].start_with?("169.254"))
+        return invalid
+      end
+
+      # Returns the port to access WinRM.
+      #
+      # @param [Vagrant::Machine] machine
+      # @return [Integer]
+      def self.winrm_port(machine, local=true)
+        host_port = machine.config.winrm.port
+        if machine.config.winrm.guest_port
+          # If we're not requesting a local port, return
+          # the guest port directly.
+          return machine.config.winrm.guest_port if !local
+
+          # Search by guest port if we can. We use a provider capability
+          # if we have it. Otherwise, we just scan the Vagrantfile defined
+          # ports.
+          port = nil
+          if machine.provider.capability?(:forwarded_ports)
+            Array(machine.provider.capability(:forwarded_ports)).each do |host, guest|
+              if guest == machine.config.winrm.guest_port
+                port = host
+                break
+              end
+            end
+          end
+
+          if !port
+            machine.config.vm.networks.each do |type, netopts|
+              next if type != :forwarded_port
+              next if !netopts[:host]
+              if netopts[:guest] == machine.config.winrm.guest_port
+                port = netopts[:host]
+                break
+              end
+            end
+          end
+
+          # Set it if we found it
+          host_port = port if port
+        end
+
+        host_port
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/bundler/gems/vagrant-22795b161bf6/plugins/communicators/winrm/plugin.rb

@@ -0,0 +1,66 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    autoload :Errors, File.expand_path("../errors", __FILE__)
+
+    class Plugin < Vagrant.plugin("2")
+      name "winrm communicator"
+      description <<-DESC
+      This plugin allows Vagrant to communicate with remote machines using
+      WinRM.
+      DESC
+
+      communicator("winrm") do
+        require File.expand_path("../communicator", __FILE__)
+        init!
+        Communicator
+      end
+
+      config("winrm") do
+        require_relative "config"
+        Config
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        @_init = true
+
+        # Setup the I18n
+        I18n.load_path << File.expand_path(
+          "templates/locales/comm_winrm.yml", Vagrant.source_root)
+        I18n.reload!
+
+        # Check if vagrant-winrm plugin is installed and
+        # output warning to user if found
+        if !ENV["VAGRANT_IGNORE_WINRM_PLUGIN"] &&
+            Vagrant::Plugin::Manager.instance.installed_plugins.keys.include?("vagrant-winrm")
+            $stderr.puts <<-EOF
+WARNING: Vagrant has detected the `vagrant-winrm` plugin. Vagrant ships with
+WinRM support builtin and no longer requires the `vagrant-winrm` plugin. To
+prevent unexpected errors please uninstall the `vagrant-winrm` plugin using
+the command shown below:
+
+  vagrant plugin uninstall vagrant-winrm
+
+To disable this warning, set the environment variable `VAGRANT_IGNORE_WINRM_PLUGIN`
+EOF
+        end
+        # Load the WinRM gem
+        require "vagrant/util/silence_warnings"
+        Vagrant::Util::SilenceWarnings.silence! do
+          require "winrm"
+        end
+      end
+
+      # @private
+      # Reset the cached init value. This is not considered a public
+      # API and should only be used for testing.
+      def self.reset!
+        send(:remove_instance_variable, :@_init)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/bundler/gems/vagrant-22795b161bf6/plugins/communicators/winrm/shell.rb

@@ -0,0 +1,262 @@
+require "timeout"
+
+require "log4r"
+
+require "vagrant/util/retryable"
+require "vagrant/util/silence_warnings"
+
+Vagrant::Util::SilenceWarnings.silence! do
+  require "winrm"
+end
+
+require "winrm-elevated"
+require "winrm-fs"
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    class WinRMShell
+      include Vagrant::Util::Retryable
+
+      # Exit code generated when user is invalid. Can occur
+      # after a hostname update
+      INVALID_USERID_EXITCODE = -2147024809
+
+      # These are the exceptions that we retry because they represent
+      # errors that are generally fixed from a retry and don't
+      # necessarily represent immediate failure cases.
+      @@exceptions_to_retry_on = [
+        HTTPClient::KeepAliveDisconnected,
+        WinRM::WinRMHTTPTransportError,
+        WinRM::WinRMAuthorizationError,
+        WinRM::WinRMWSManFault,
+        Errno::EACCES,
+        Errno::EADDRINUSE,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::ENETUNREACH,
+        Errno::EHOSTUNREACH,
+        Timeout::Error
+      ]
+
+      attr_reader :logger
+      attr_reader :host
+      attr_reader :port
+      attr_reader :username
+      attr_reader :password
+      attr_reader :execution_time_limit
+      attr_reader :config
+
+      def initialize(host, port, config)
+        @logger = Log4r::Logger.new("vagrant::communication::winrmshell")
+        @logger.debug("initializing WinRMShell")
+
+        @host                  = host
+        @port                  = port
+        @username              = config.username
+        @password              = config.password
+        @execution_time_limit  = config.execution_time_limit
+        @config                = config
+      end
+
+      def powershell(command, opts = {}, &block)
+        connection.shell(:powershell) do |shell|
+          execute_with_rescue(shell, command, &block)
+        end
+      end
+
+      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 elevated(command, opts = {}, &block)
+        connection.shell(:elevated) do |shell|
+          shell.interactive_logon = opts[:interactive] || false
+          result = execute_with_rescue(shell, command, &block)
+          if result.exitcode == INVALID_USERID_EXITCODE && result.stderr.include?(":UserId:")
+            uname = shell.username
+            ename = elevated_username
+            if uname != ename
+              @logger.warn("elevated command failed due to username error")
+              @logger.warn("retrying command using machine prefixed username - #{ename}")
+              begin
+                shell.username = ename
+                result = execute_with_rescue(shell, command, &block)
+              ensure
+                shell.username = uname
+              end
+            end
+          end
+          result
+        end
+      end
+
+      def wql(query, opts = {}, &block)
+        retryable(tries: @config.max_tries, on: @@exceptions_to_retry_on, sleep: @config.retry_delay) do
+          connection.run_wql(query)
+        end
+      rescue => e
+        raise_winrm_exception(e, "run_wql", query)
+      end
+
+      # @param from [Array<String>, String] a single path or folder, or an
+      #        array of paths and folders to upload to the guest
+      # @param to [String] a path or folder on the guest to upload to
+      # @return [FixNum] Total size transfered from host to guest
+      def upload(from, to)
+        file_manager = WinRM::FS::FileManager.new(connection)
+        if from.is_a?(String) && File.directory?(from)
+          if from.end_with?(".")
+            from = from[0, from.length - 1]
+          else
+            to = File.join(to, File.basename(File.expand_path(from)))
+          end
+        end
+        if from.is_a?(Array)
+          # Preserve return FixNum of bytes transfered
+          return_bytes = 0
+          from.each do |file|
+            return_bytes += file_manager.upload(file, to)
+          end
+          return return_bytes
+        else
+          file_manager.upload(from, to)
+        end
+      end
+
+      def download(from, to)
+        file_manager = WinRM::FS::FileManager.new(connection)
+        file_manager.download(from, to)
+      end
+
+      protected
+
+      def execute_with_rescue(shell, command, &block)
+        handle_output(shell, command, &block)
+      rescue => e
+        raise_winrm_exception(e, shell.class.name.split("::").last, command)
+      end
+
+      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
+
+        @logger.debug("Output: #{output.inspect}")
+
+        # 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
+          if output.stderr.include?("ParserError")
+            @logger.warn("Detected ParserError, setting exit code to 1")
+            output.exitcode = 1
+          end
+        end
+
+        return output
+      end
+
+      def raise_winrm_exception(exception, shell = nil, command = nil)
+        case exception
+        when WinRM::WinRMAuthorizationError
+          raise Errors::AuthenticationFailed,
+              user: @config.username,
+              password: @config.password,
+              endpoint: endpoint,
+              message: exception.message
+        when WinRM::WinRMHTTPTransportError
+          raise Errors::ExecutionError,
+            shell: shell,
+            command: command,
+            message: exception.message
+        when OpenSSL::SSL::SSLError
+          raise Errors::SSLError, message: exception.message
+        when HTTPClient::TimeoutError
+          raise Errors::ConnectionTimeout, message: exception.message
+        when Errno::ETIMEDOUT
+          raise Errors::ConnectionTimeout
+          # This is raised if the connection timed out
+        when Errno::ECONNREFUSED
+          # This is raised if we failed to connect the max amount of times
+          raise Errors::ConnectionRefused
+        when Errno::ECONNRESET
+          # This is raised if we failed to connect the max number of times
+          # due to an ECONNRESET.
+          raise Errors::ConnectionReset
+        when Errno::EHOSTDOWN
+          # This is raised if we get an ICMP DestinationUnknown error.
+          raise Errors::HostDown
+        when Errno::EHOSTUNREACH
+          # This is raised if we can't work out how to route traffic.
+          raise Errors::NoRoute
+        else
+          raise Errors::ExecutionError,
+            shell: shell,
+            command: command,
+            message: exception.message
+        end
+      end
+
+      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::Connection.new(endpoint_options)
+        client.logger = @logger
+        client
+      end
+
+      def connection
+        @connection ||= new_connection
+      end
+
+      def endpoint
+        case @config.transport.to_sym
+        when :ssl
+          "https://#{@host}:#{@port}/wsman"
+        when :plaintext, :negotiate
+          "http://#{@host}:#{@port}/wsman"
+        else
+          raise Errors::WinRMInvalidTransport, transport: @config.transport
+        end
+      end
+
+      def endpoint_options
+        { endpoint: endpoint,
+          transport: @config.transport,
+          operation_timeout: @config.timeout,
+          user: @username,
+          password: @password,
+          host: @host,
+          port: @port,
+          basic_auth_only: @config.basic_auth_only,
+          no_ssl_peer_verification: !@config.ssl_peer_verification,
+          retry_delay: @config.retry_delay,
+          retry_limit: @config.max_tries }
+      end
+
+      def elevated_username
+        if username.include?("\\")
+          return username
+        end
+        computername = ""
+        powershell("Write-Output $env:computername") do |type, data|
+          computername << data if type == :stdout
+        end
+        computername.strip!
+        if computername.empty?
+          return username
+        end
+        "#{computername}\\#{username}"
+      end
+    end #WinShell class
+  end
+end

data/vendor/bundle/ruby/2.7.0/bundler/gems/vagrant-22795b161bf6/plugins/communicators/winssh/communicator.rb

@@ -0,0 +1,249 @@
+require File.expand_path("../../ssh/communicator", __FILE__)
+
+require 'net/sftp'
+
+module VagrantPlugins
+  module CommunicatorWinSSH
+    # This class provides communication with a Windows VM running
+    # the Windows native port of OpenSSH
+    class Communicator < VagrantPlugins::CommunicatorSSH::Communicator
+      # Command to run when checking if connection is ready and working
+      READY_COMMAND="dir"
+
+      def initialize(machine)
+        super
+        @logger = Log4r::Logger.new("vagrant::communication::winssh")
+      end
+
+      # Wrap the shell if required. By default we are using powershell
+      # which requires no modification. If cmd is defined as shell, add
+      # prefix to start within cmd.exe
+      def shell_cmd(opts)
+        case opts[:shell].to_s
+        when "cmd"
+          "cmd.exe /c '#{opts[:command]}'"
+        else
+          opts[:command]
+        end
+      end
+
+      # Executes the command on an SSH connection within a login shell.
+      def shell_execute(connection, command, **opts)
+        opts[:shell] ||= machine_config_ssh.shell
+
+        command = shell_cmd(opts.merge(command: command))
+
+        @logger.info("Execute: #{command} - opts: #{opts}")
+        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 = ''
+
+          @logger.debug("Base SSH exec command: #{command}")
+          command = "$ProgressPreference = 'SilentlyContinue';Write-Output #{CMD_GARBAGE_MARKER};[Console]::Error.WriteLine('#{CMD_GARBAGE_MARKER}');#{command}"
+
+          ch.exec(command) 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
+                  stderr_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? && stderr_marker_found && !data.empty?
+                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
+
+      def download(from, to=nil)
+        @logger.debug("Downloading: #{from} to #{to}")
+
+        sftp_connect do |sftp|
+          sftp.download!(from, to)
+        end
+      end
+
+      # Note: I could not get Net::SFTP to throw a permissions denied error,
+      # even when uploading to a directory where I did not have write
+      # privileges. I believe this is because Windows SSH sessions are started
+      # in an elevated process.
+      def upload(from, to)
+        to = Vagrant::Util::Platform.unix_windows_path(to)
+        @logger.debug("Uploading: #{from} to #{to}")
+
+        if File.directory?(from)
+          if from.end_with?(".")
+            @logger.debug("Uploading directory contents of: #{from}")
+            from = from.sub(/\.$/, "")
+          else
+            @logger.debug("Uploading full directory container of: #{from}")
+            to = File.join(to, File.basename(File.expand_path(from)))
+          end
+        end
+
+        sftp_connect do |sftp|
+          uploader = lambda do |path, remote_dest=nil|
+            if File.directory?(path)
+              Dir.new(path).each do |entry|
+                next if entry == "." || entry == ".."
+                full_path = File.join(path, entry)
+                dest = File.join(to, path.sub(/^#{Regexp.escape(from)}/, ""))
+                sftp.mkdir(dest)
+                uploader.call(full_path, dest)
+              end
+            else
+              if remote_dest
+                dest = File.join(remote_dest, File.basename(path))
+              else
+                dest = to
+                if to.end_with?(File::SEPARATOR)
+                  dest = File.join(to, File.basename(path))
+                end
+              end
+              @logger.debug("Ensuring remote directory exists for destination upload")
+              sftp.mkdir(File.dirname(dest))
+              @logger.debug("Uploading file #{path} to remote #{dest}")
+              upload_file = File.open(path, "rb")
+              begin
+                sftp.upload!(upload_file, dest)
+              ensure
+                upload_file.close
+              end
+            end
+          end
+          uploader.call(from)
+        end
+      end
+
+      # Opens an SFTP connection and yields it so that you can download and
+      # upload files. SFTP works more reliably than SCP on Windows due to
+      # issues with shell quoting and escaping.
+      def sftp_connect
+        # Connect to SFTP and yield the SFTP object
+        connect do |connection|
+          return yield connection.sftp
+        end
+      end
+
+      protected
+
+      # The WinSSH communicator connection provides isolated modification
+      # to the generated connection instances. This modification forces
+      # all provided commands to run within powershell
+      def connect(**opts)
+        connection = nil
+        super { |c| connection = c }
+
+        if !connection.instance_variable_get(:@winssh_patched)
+          open_chan = connection.method(:open_channel)
+          connection.define_singleton_method(:open_channel) do |*args, &chan_block|
+            open_chan.call(*args) do |ch|
+              exec = ch.method(:exec)
+              ch.define_singleton_method(:exec) do |command, &block|
+                command = Base64.strict_encode64(command.encode("UTF-16LE", "UTF-8"))
+                command = "powershell -NoLogo -NonInteractive -ExecutionPolicy Bypass " \
+                  "-NoProfile -EncodedCommand #{command}"
+                exec.call(command, &block)
+              end
+              chan_block.call(ch)
+            end
+          end
+          connection.instance_variable_set(:@winssh_patched, true)
+        end
+
+        if block_given?
+          yield connection
+        else
+          connection
+        end
+      end
+    end
+  end
+end