vagrant-aws-mkubenka 0.7.2.pre.14 → 0.7.2.pre.16

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/communicators/winrm/shell.rb

@@ -1,208 +0,0 @@
-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
-
-      # 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
-          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
-          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(connection)
-        file_manager.upload(from, to)
-      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
-    end #WinShell class
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/communicators/winssh/communicator.rb

@@ -1,161 +0,0 @@
-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/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/communicators/winssh/config.rb

@@ -1,30 +0,0 @@
-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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/darwin/cap/shell_expand_guest_path.rb

@@ -1,26 +0,0 @@
-module VagrantPlugins
-  module GuestDarwin
-    module Cap
-      class ShellExpandGuestPath
-        def self.shell_expand_guest_path(machine, path)
-          real_path = nil
-          machine.communicate.execute("printf #{path}") do |type, data|
-            if type == :stdout
-              real_path ||= ""
-              real_path += data
-            end
-          end
-
-          if !real_path
-            # If no real guest path was detected, this is really strange
-            # and we raise an exception because this is a bug.
-            raise ShellExpandFailed
-          end
-
-          # Chomp the string so that any trailing newlines are killed
-          return real_path.chomp
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/freebsd/cap/configure_networks.rb

@@ -1,67 +0,0 @@
-require "tempfile"
-
-require_relative "../../../../lib/vagrant/util/template_renderer"
-
-module VagrantPlugins
-  module GuestFreeBSD
-    module Cap
-      class ConfigureNetworks
-        include Vagrant::Util
-
-        def self.configure_networks(machine, networks)
-          options = { shell: "sh" }
-          comm = machine.communicate
-
-          commands   = []
-          interfaces = []
-
-          # Remove any previous network additions to the configuration file.
-          commands << "sed -i'' -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/rc.conf"
-
-          comm.sudo("ifconfig -a | grep -o ^[0-9a-z]* | grep -v '^lo'", options) do |_, stdout|
-            interfaces = stdout.split("\n")
-          end
-
-          networks.each.with_index do |network, i|
-            network[:device] = interfaces[network[:interface]]
-
-            entry = TemplateRenderer.render("guests/freebsd/network_#{network[:type]}",
-              options: network,
-            )
-
-            remote_path = "/tmp/vagrant-network-#{network[:device]}-#{Time.now.to_i}-#{i}"
-
-            Tempfile.open("vagrant-freebsd-configure-networks") do |f|
-              f.binmode
-              f.write(entry)
-              f.fsync
-              f.close
-              comm.upload(f.path, remote_path)
-            end
-
-            commands << <<-EOH.gsub(/^ {14}/, '')
-              cat '#{remote_path}' >> /etc/rc.conf
-              rm -f '#{remote_path}'
-            EOH
-
-            # If the network is DHCP, then we have to start the dhclient, unless
-            # it is already running. See GH-5852 for more information
-            if network[:type].to_sym == :dhcp
-              file = "/var/run/dhclient.#{network[:device]}.pid"
-              commands << <<-EOH.gsub(/^ {16}/, '')
-                if ! test -f '#{file}' || ! kill -0 $(cat '#{file}'); then
-                  dhclient '#{network[:device]}'
-                fi
-              EOH
-            end
-
-            # For some reason, this returns status 1... every time
-            commands << "/etc/rc.d/netif restart '#{network[:device]}' || true"
-          end
-
-          comm.sudo(commands.join("\n"), options)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/freebsd/cap/shell_expand_guest_path.rb

@@ -1,27 +0,0 @@
-module VagrantPlugins
-  module GuestFreeBSD
-    module Cap
-      class ShellExpandGuestPath
-        def self.shell_expand_guest_path(machine, path)
-          real_path = nil
-          machine.communicate.execute("printf #{path}",
-                                      shell: "sh") do |type, data|
-            if type == :stdout
-              real_path ||= ""
-              real_path += data
-            end
-          end
-
-          if !real_path
-            # If no real guest path was detected, this is really strange
-            # and we raise an exception because this is a bug.
-            raise ShellExpandFailed
-          end
-
-          # Chomp the string so that any trailing newlines are killed
-          return real_path.chomp
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/linux/cap/shell_expand_guest_path.rb

@@ -1,31 +0,0 @@
-module VagrantPlugins
-  module GuestLinux
-    module Cap
-      class ShellExpandGuestPath
-        def self.shell_expand_guest_path(machine, path)
-          real_path = nil
-          machine.communicate.execute("echo; printf #{path}") do |type, data|
-            if type == :stdout
-              real_path ||= ""
-              real_path += data
-            end
-          end
-
-          if real_path
-            # The last line is the path we care about
-            real_path = real_path.split("\n").last.chomp
-          end
-
-          if !real_path
-            # If no real guest path was detected, this is really strange
-            # and we raise an exception because this is a bug.
-            raise ShellExpandFailed
-          end
-
-          # Chomp the string so that any trailing newlines are killed
-          return real_path.chomp
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/netbsd/cap/shell_expand_guest_path.rb

@@ -1,26 +0,0 @@
-module VagrantPlugins
-  module GuestNetBSD
-    module Cap
-      class ShellExpandGuestPath
-        def self.shell_expand_guest_path(machine, path)
-          real_path = nil
-          machine.communicate.execute("printf #{path}") do |type, data|
-            if type == :stdout
-              real_path ||= ""
-              real_path += data
-            end
-          end
-
-          if !real_path
-            # If no real guest path was detected, this is really strange
-            # and we raise an exception because this is a bug.
-            raise ShellExpandFailed
-          end
-
-          # Chomp the string so that any trailing newlines are killed
-          return real_path.chomp
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/openbsd/cap/shell_expand_guest_path.rb

@@ -1,26 +0,0 @@
-module VagrantPlugins
-  module GuestOpenBSD
-    module Cap
-      class ShellExpandGuestPath
-        def self.shell_expand_guest_path(machine, path)
-          real_path = nil
-          machine.communicate.execute("printf #{path}") do |type, data|
-            if type == :stdout
-              real_path ||= ""
-              real_path += data
-            end
-          end
-
-          if !real_path
-            # If no real guest path was detected, this is really strange
-            # and we raise an exception because this is a bug.
-            raise ShellExpandFailed
-          end
-
-          # Chomp the string so that any trailing newlines are killed
-          return real_path.chomp
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/smartos/cap/change_host_name.rb

@@ -1,17 +0,0 @@
-module VagrantPlugins
-  module GuestSmartos
-    module Cap
-      class ChangeHostName
-        def self.change_host_name(machine, name)
-          su_cmd = machine.config.smartos.suexec_cmd
-
-          # Only do this if the hostname is not already set
-          if !machine.communicate.test("hostname | grep '#{name}'")
-            machine.communicate.execute("#{su_cmd} sh -c \"echo '#{name}' > /etc/nodename\"")
-            machine.communicate.execute("#{su_cmd} hostname #{name}")
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/smartos/cap/mount_nfs.rb

@@ -1,19 +0,0 @@
-module VagrantPlugins
-  module GuestSmartos
-    module Cap
-      class MountNFS
-        def self.mount_nfs_folder(machine, ip, folders)
-          sudo = machine.config.smartos.suexec_cmd
-
-          folders.each do |name, opts|
-            machine.communicate.tap do |comm|
-              comm.execute("#{sudo} mkdir -p #{opts[:guestpath]}", {shell: "sh"})
-              comm.execute("#{sudo} /usr/sbin/mount -F nfs '#{ip}:#{opts[:hostpath]}' '#{opts[:guestpath]}'", {shell: "sh"})
-            end
-          end
-        end
-      end
-    end
-  end
-end
-

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/windows/errors.rb

@@ -1,18 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    module Errors
-      # A convenient superclass for all our errors.
-      class WindowsError < Vagrant::Errors::VagrantError
-        error_namespace("vagrant_windows.errors")
-      end
-
-      class NetworkWinRMRequired < WindowsError
-        error_key(:network_winrm_required)
-      end
-
-      class RenameComputerFailed < WindowsError
-        error_key(:rename_computer_failed)
-      end
-    end
-  end
-end