vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/communicators/winrm/errors.rb

@@ -1,69 +0,0 @@
-module VagrantPlugins
-  module CommunicatorWinRM
-    module Errors
-      # A convenient superclass for all our errors.
-      class WinRMError < Vagrant::Errors::VagrantError
-        error_namespace("vagrant_winrm.errors")
-      end
-
-      class TransientError < WinRMError
-      end
-
-      class AuthenticationFailed < WinRMError
-        error_key(:authentication_failed)
-      end
-
-      class ExecutionError < WinRMError
-        error_key(:execution_error)
-      end
-
-      class InvalidShell < WinRMError
-        error_key(:invalid_shell)
-      end
-
-      class WinRMBadExitStatus < WinRMError
-        error_key(:winrm_bad_exit_status)
-      end
-
-      class WinRMNotReady < WinRMError
-        error_key(:winrm_not_ready)
-      end
-
-      class WinRMFileTransferError < WinRMError
-        error_key(:winrm_file_transfer_error)
-      end
-
-      class InvalidTransport < WinRMError
-        error_key(:invalid_transport)
-      end
-
-      class SSLError < WinRMError
-        error_key(:ssl_error)
-      end
-
-      class ConnectionTimeout < TransientError
-        error_key(:connection_timeout)
-      end
-
-      class Disconnected < TransientError
-        error_key(:disconnected)
-      end
-
-      class ConnectionRefused < TransientError
-        error_key(:connection_refused)
-      end
-
-      class ConnectionReset < TransientError
-        error_key(:connection_reset)
-      end
-
-      class HostDown < TransientError
-        error_key(:host_down)
-      end
-
-      class NoRoute < TransientError
-        error_key(:no_route)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/communicators/winrm/helper.rb

@@ -1,88 +0,0 @@
-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)
-            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.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/communicators/winrm/plugin.rb

@@ -1,44 +0,0 @@
-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!
-
-        # Load the WinRM gem
-        require "vagrant/util/silence_warnings"
-        Vagrant::Util::SilenceWarnings.silence! do
-          require "winrm"
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/communicators/winrm/shell.rb

@@ -1,221 +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
-
-      # @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?(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
-    end #WinShell class
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/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 = "#{machine_config_ssh.upload_directory}\\#{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.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/communicators/winssh/config.rb

@@ -1,38 +0,0 @@
-require File.expand_path("../../../kernel_v2/config/ssh", __FILE__)
-
-module VagrantPlugins
-  module CommunicatorWinSSH
-    class Config < VagrantPlugins::Kernel_V2::SSHConfig
-
-      attr_accessor :upload_directory
-
-      def initialize
-        super
-        @upload_directory = UNSET_VALUE
-      end
-
-      def finalize!
-        @shell = "cmd" if @shell == UNSET_VALUE
-        @sudo_command = "%c" if @sudo_command == UNSET_VALUE
-        @upload_directory = "C:\\Windows\\Temp" if @upload_directory == 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.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/communicators/winssh/plugin.rb

@@ -1,21 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommunicatorWinSSH
-    class Plugin < Vagrant.plugin("2")
-      name "windows ssh communicator"
-      description <<-DESC
-      DESC
-
-      communicator("winssh") do
-        require File.expand_path("../communicator", __FILE__)
-        Communicator
-      end
-
-      config("winssh") do
-        require_relative "config"
-        Config
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/alt/cap/change_host_name.rb

@@ -1,46 +0,0 @@
-module VagrantPlugins
-  module GuestALT
-    module Cap
-      class ChangeHostName
-        def self.change_host_name(machine, name)
-          comm = machine.communicate
-
-          if !comm.test("hostname -f | grep '^#{name}$'", sudo: false)
-            basename = name.split('.', 2)[0]
-            comm.sudo <<-EOH.gsub(/^ {14}/, '')
-              # Save current hostname saved in /etc/hosts
-              CURRENT_HOSTNAME_FULL="$(hostname -f)"
-              CURRENT_HOSTNAME_SHORT="$(hostname -s)"
-
-              # New hostname to be saved in /etc/hosts
-              NEW_HOSTNAME_FULL='#{name}'
-              NEW_HOSTNAME_SHORT="${NEW_HOSTNAME_FULL%%.*}"
-
-              # Update sysconfig
-              sed -i 's/\\(HOSTNAME=\\).*/\\1#{name}/' /etc/sysconfig/network
-
-              # Set the hostname - use hostnamectl if available
-              if command -v hostnamectl; then
-                hostnamectl set-hostname --static '#{name}'
-                hostnamectl set-hostname --transient '#{name}'
-              else
-                hostname '#{name}'
-              fi
-
-              # Update ourselves in /etc/hosts
-              if grep -w "$CURRENT_HOSTNAME_FULL" /etc/hosts; then
-                sed -i -e "s/\(\s\)$CURRENT_HOSTNAME_FULL\(\s\)/\1$NEW_HOSTNAME_FULL\2/g" -e "s/\(\s\)$CURRENT_HOSTNAME_FULL$/\1$NEW_HOSTNAME_FULL/g" /etc/hosts
-              fi
-              if grep -w "$CURRENT_HOSTNAME_SHORT" /etc/hosts; then
-                sed -i -e "s/\(\s\)$CURRENT_HOSTNAME_SHORT\(\s\)/\1$NEW_HOSTNAME_SHORT\2/g" -e "s/\(\s\)$CURRENT_HOSTNAME_SHORT$/\1$NEW_HOSTNAME_SHORT/g" /etc/hosts
-              fi
-
-              # Restart network
-              service network restart
-            EOH
-          end
-        end
-      end
-    end
-  end
-end