vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/util/ssh.rb

@@ -1,232 +0,0 @@
-require "log4r"
-
-require 'childprocess'
-
-require "vagrant/util/file_mode"
-require "vagrant/util/platform"
-require "vagrant/util/safe_exec"
-require "vagrant/util/safe_puts"
-require "vagrant/util/subprocess"
-require "vagrant/util/which"
-
-module Vagrant
-  module Util
-    # This is a class that has helpers on it for dealing with SSH. These
-    # helpers don't depend on any part of Vagrant except what is given
-    # via the parameters.
-    class SSH
-      extend SafePuts
-
-      LOGGER = Log4r::Logger.new("vagrant::util::ssh")
-
-      # Checks that the permissions for a private key are valid, and fixes
-      # them if possible. SSH requires that permissions on the private key
-      # are 0600 on POSIX based systems. This will make a best effort to
-      # fix these permissions if they are not properly set.
-      #
-      # @param [Pathname] key_path The path to the private key.
-      def self.check_key_permissions(key_path)
-        # Don't do anything if we're on Windows, since Windows doesn't worry
-        # about key permissions.
-        return if Platform.windows? || Platform.wsl_windows_access_bypass?(key_path)
-
-        LOGGER.debug("Checking key permissions: #{key_path}")
-        stat = key_path.stat
-
-        if !stat.owned? && Process.uid != 0
-          # The SSH key must be owned by ourselves, unless we're root
-          raise Errors::SSHKeyBadOwner, key_path: key_path
-        end
-
-        if FileMode.from_octal(stat.mode) != "600"
-          LOGGER.info("Attempting to correct key permissions to 0600")
-          key_path.chmod(0600)
-
-          # Re-stat the file to get the new mode, and verify it worked
-          stat = key_path.stat
-          if FileMode.from_octal(stat.mode) != "600"
-            raise Errors::SSHKeyBadPermissions, key_path: key_path
-          end
-        end
-      rescue Errno::EPERM
-        # This shouldn't happen since we verify we own the file, but
-        # it is possible in theory, so we raise an error.
-        raise Errors::SSHKeyBadPermissions, key_path: key_path
-      end
-
-      # Halts the running of this process and replaces it with a full-fledged
-      # SSH shell into a remote machine.
-      #
-      # Note: This method NEVER returns. The process ends after this.
-      #
-      # @param [Hash] ssh_info This is the SSH information. For the keys
-      #   required please see the documentation of {Machine#ssh_info}.
-      # @param [Hash] opts These are additional options that are supported
-      #   by exec.
-      def self.exec(ssh_info, opts={})
-        # Ensure the platform supports ssh. On Windows there are several programs which
-        # include ssh, notably git, mingw and cygwin, but make sure ssh is in the path!
-
-        # First try using the original path provided
-        if ENV["VAGRANT_PREFER_SYSTEM_BIN"] != "0"
-          ssh_path = Which.which("ssh", original_path: true)
-        end
-
-        # If we didn't find an ssh executable, see if we shipped one
-        if !ssh_path
-          ssh_path = Which.which("ssh")
-          if ssh_path && Platform.windows? && (Platform.cygwin? || Platform.msys?)
-            LOGGER.warn("Failed to locate native SSH executable. Using vendored version.")
-            LOGGER.warn("If display issues are encountered, install the ssh package for your environment.")
-          end
-        end
-
-        if !ssh_path
-          if Platform.windows?
-            raise Errors::SSHUnavailableWindows,
-              host: ssh_info[:host],
-              port: ssh_info[:port],
-              username: ssh_info[:username],
-              key_path: ssh_info[:private_key_path].join(", ")
-          end
-
-          raise Errors::SSHUnavailable
-        end
-
-        if Platform.windows?
-          # On Windows, we need to detect whether SSH is actually "plink"
-          # underneath the covers. In this case, we tell the user.
-          r = Subprocess.execute(ssh_path)
-          if r.stdout.include?("PuTTY Link") || r.stdout.include?("Plink: command-line connection utility")
-            raise Errors::SSHIsPuttyLink,
-              host: ssh_info[:host],
-              port: ssh_info[:port],
-              username: ssh_info[:username],
-              key_path: ssh_info[:private_key_path].join(", ")
-          end
-        end
-
-        # If plain mode is enabled then we don't do any authentication (we don't
-        # set a user or an identity file)
-        plain_mode = opts[:plain_mode]
-
-        options = {}
-        options[:host] = ssh_info[:host]
-        options[:port] = ssh_info[:port]
-        options[:username] = ssh_info[:username]
-        options[:private_key_path] = ssh_info[:private_key_path]
-
-        log_level = ssh_info[:log_level] || "FATAL"
-
-        # Command line options
-        command_options = [
-          "-p", options[:port].to_s,
-          "-o", "LogLevel=#{log_level}"]
-
-        if ssh_info[:compression]
-          command_options += ["-o", "Compression=yes"]
-        end
-
-        if ssh_info[:dsa_authentication]
-          command_options += ["-o", "DSAAuthentication=yes"]
-        end
-
-        # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the
-        # IdentitiesOnly option. Also, we don't enable it in plain mode or if
-        # if keys_only is false so that SSH and Net::SSH properly search our identities
-        # and tries to do it itself.
-        if !Platform.solaris? && !plain_mode && ssh_info[:keys_only]
-          command_options += ["-o", "IdentitiesOnly=yes"]
-        end
-
-        # no strict hostkey checking unless paranoid
-        if ! ssh_info[:verify_host_key]
-          command_options += [
-            "-o", "StrictHostKeyChecking=no",
-            "-o", "UserKnownHostsFile=/dev/null"]
-        end
-
-        # If we're not in plain mode and :private_key_path is set attach the private key path(s).
-        if !plain_mode && options[:private_key_path]
-          options[:private_key_path].each do |path|
-
-            # Use '-o' instead of '-i' because '-i' does not call
-            # percent_expand in misc.c, but '-o' does. when passing the path,
-            # replace '%' in the path with '%%' to escape the '%'
-            path = path.to_s.gsub('%', '%%')
-            command_options += ["-o", "IdentityFile=\"#{path}\""]
-          end
-        end
-
-        if ssh_info[:forward_x11]
-          # Both are required so that no warnings are shown regarding X11
-          command_options += [
-            "-o", "ForwardX11=yes",
-            "-o", "ForwardX11Trusted=yes"]
-        end
-
-        if ssh_info[:proxy_command]
-          command_options += ["-o", "ProxyCommand=#{ssh_info[:proxy_command]}"]
-        end
-
-        if ssh_info[:forward_env]
-          command_options += ["-o", "SendEnv=#{ssh_info[:forward_env].join(" ")}"]
-        end
-
-        # Configurables -- extra_args should always be last due to the way the
-        # ssh args parser works. e.g. if the user wants to use the -t option,
-        # any shell command(s) she'd like to run on the remote server would
-        # have to be the last part of the 'ssh' command:
-        #
-        #   $ ssh localhost -t -p 2222 "cd mydirectory; bash"
-        #
-        # Without having extra_args be last, the user loses this ability
-        command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
-
-        # Note about :extra_args
-        #   ssh_info[:extra_args] comes from a machines ssh config in a Vagrantfile,
-        #   where as opts[:extra_args] comes from running the ssh command
-        command_options += Array(ssh_info[:extra_args]) if ssh_info[:extra_args]
-
-        command_options.concat(opts[:extra_args]) if opts[:extra_args]
-
-        # Build up the host string for connecting
-        host_string = options[:host]
-        host_string = "#{options[:username]}@#{host_string}" if !plain_mode
-        command_options.unshift(host_string)
-
-        # On Cygwin we want to get rid of any DOS file warnings because
-        # we really don't care since both work.
-        ENV["nodosfilewarning"] = "1" if Platform.cygwin?
-
-        # If an ssh command is defined, use that. If an ssh binary was
-        # discovered on the path, use that. Otherwise fail to just trying `ssh`
-        ssh = ssh_info[:ssh_command] || ssh_path || 'ssh'
-
-        # Invoke SSH with all our options
-        if !opts[:subprocess]
-          LOGGER.info("Invoking SSH: #{ssh} #{command_options.inspect}")
-          SafeExec.exec(ssh, *command_options)
-          return
-        end
-
-        # If we're still here, it means we're supposed to subprocess
-        # out to ssh rather than exec it.
-        LOGGER.info("Executing SSH in subprocess: #{ssh} #{command_options.inspect}")
-        process = ChildProcess.build(ssh, *command_options)
-        process.io.inherit!
-
-        # Forward configured environment variables.
-        if ssh_info[:forward_env]
-          ssh_info[:forward_env].each do |key|
-            process.environment[key] = ENV[key]
-          end
-        end
-
-        process.start
-        process.wait
-        return process.exit_code
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/util/stacked_proc_runner.rb

@@ -1,35 +0,0 @@
-module Vagrant
-  module Util
-    # Represents the "stacked proc runner" behavior which is used a
-    # couple places within Vagrant. This allows procs to "stack" on
-    # each other, then all execute in a single action. An example of
-    # its uses can be seen in the {Config} class.
-    module StackedProcRunner
-      # Returns the proc stack. This should always be called as the
-      # accessor of the stack. The instance variable itself should _never_
-      # be used.
-      #
-      # @return [Array<Proc>]
-      def proc_stack
-        @_proc_stack ||= []
-      end
-
-      # Adds (pushes) a proc to the stack. The actual proc added here is
-      # not executed, but merely stored.
-      #
-      # @param [Proc] block
-      def push_proc(&block)
-        proc_stack << block
-      end
-
-      # Executes all the procs on the stack, passing in the given arguments.
-      # The stack is not cleared afterwards. It is up to the user of this
-      # mixin to clear the stack by calling `proc_stack.clear`.
-      def run_procs!(*args)
-        proc_stack.each do |proc|
-          proc.call(*args)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/util/string_block_editor.rb

@@ -1,77 +0,0 @@
-module Vagrant
-  module Util
-    # This class modifies strings by creating and managing Vagrant-owned
-    # "blocks" via wrapping them in specially formed comments.
-    #
-    # This is useful when modifying a file that someone else owns and adding
-    # automatic entries into it. Example: /etc/exports or some other
-    # configuration file.
-    #
-    # Vagrant marks ownership of a block in the string by wrapping it in
-    # VAGRANT-BEGIN and VAGRANT-END comments with a unique ID. Example:
-    #
-    #     foo
-    #     # VAGRANT-BEGIN: id
-    #     some contents
-    #     created by vagrant
-    #     # VAGRANT-END: id
-    #
-    # The goal of this class is to be able to insert and remove these
-    # blocks without modifying anything else in the string.
-    #
-    # The strings usually come from files but it is up to the caller to
-    # manage the file resource.
-    class StringBlockEditor
-      # The current string value. This is the value that is modified by
-      # the methods below.
-      #
-      # @return [String]
-      attr_reader :value
-
-      def initialize(string)
-        @value = string
-      end
-
-      # This returns the keys (or ids) that are in the string.
-      #
-      # @return [<Array<String>]
-      def keys
-        regexp = /^#\s*VAGRANT-BEGIN:\s*(.+?)$\r?\n?(.*)$\r?\n?^#\s*VAGRANT-END:\s(\1)$/m
-        @value.scan(regexp).map do |match|
-          match[0]
-        end
-      end
-
-      # This deletes the block with the given key if it exists.
-      def delete(key)
-        key    = Regexp.quote(key)
-        regexp = /^#\s*VAGRANT-BEGIN:\s*#{key}$.*^#\s*VAGRANT-END:\s*#{key}$\r?\n?/m
-        @value.gsub!(regexp, "")
-      end
-
-      # This gets the value of the block with the given key.
-      def get(key)
-        key    = Regexp.quote(key)
-        regexp = /^#\s*VAGRANT-BEGIN:\s*#{key}$\r?\n?(.*?)\r?\n?^#\s*VAGRANT-END:\s*#{key}$\r?\n?/m
-        match  = regexp.match(@value)
-        return nil if !match
-        match[1]
-      end
-
-      # This inserts a block with the given key and value.
-      #
-      # @param [String] key
-      # @param [String] value
-      def insert(key, value)
-        # Insert the new block into the value
-        new_block = <<BLOCK
-# VAGRANT-BEGIN: #{key}
-#{value.strip}
-# VAGRANT-END: #{key}
-BLOCK
-
-        @value << new_block
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/util/subprocess.rb

@@ -1,342 +0,0 @@
-require 'thread'
-
-require 'childprocess'
-require 'log4r'
-
-require 'vagrant/util/io'
-require 'vagrant/util/platform'
-require 'vagrant/util/safe_chdir'
-require 'vagrant/util/which'
-
-module Vagrant
-  module Util
-    # Execute a command in a subprocess, gathering the results and
-    # exit status.
-    #
-    # This class also allows you to read the data as it is outputted
-    # from the subprocess in real time, by simply passing a block to
-    # the execute method.
-    class Subprocess
-      # Convenience method for executing a method.
-      def self.execute(*command, &block)
-        new(*command).execute(&block)
-      end
-
-      def initialize(*command)
-        @options = command.last.is_a?(Hash) ? command.pop : {}
-        @command = command.dup
-        @command[0] = Which.which(@command[0]) if !File.file?(@command[0])
-        if !@command[0]
-          raise Errors::CommandUnavailableWindows, file: command[0] if Platform.windows?
-          raise Errors::CommandUnavailable, file: command[0]
-        end
-
-        @logger  = Log4r::Logger.new("vagrant::util::subprocess")
-      end
-
-      # @return [TrueClass, FalseClass] subprocess is currently running
-      def running?
-        !!(@process && @process.alive?)
-      end
-
-      # Stop the subprocess if running
-      #
-      # @return [TrueClass] FalseClass] true if process was running and stopped
-      def stop
-        if @process && @process.alive?
-          @process.stop
-          true
-        else
-          false
-        end
-      end
-
-      # Start the process
-      #
-      # @return [Result]
-      def execute
-        # Get the timeout, if we have one
-        timeout = @options[:timeout]
-
-        # Get the working directory
-        workdir = @options[:workdir] || Dir.pwd
-
-        # Get what we're interested in being notified about
-        notify  = @options[:notify] || []
-        notify  = [notify] if !notify.is_a?(Array)
-        if notify.empty? && block_given?
-          # If a block is given, subscribers must be given, otherwise the
-          # block is never called. This is usually NOT what you want, so this
-          # is an error.
-          message = "A list of notify subscriptions must be given if a block is given"
-          raise ArgumentError, message
-        end
-
-        # Let's get some more useful booleans that we access a lot so
-        # we're not constantly calling an `include` check
-        notify_table = {}
-        notify_table[:stderr] = notify.include?(:stderr)
-        notify_table[:stdout] = notify.include?(:stdout)
-        notify_stdin  = notify.include?(:stdin)
-
-        # Build the ChildProcess
-        @logger.info("Starting process: #{@command.inspect}")
-        @process = process = ChildProcess.build(*@command)
-
-        # Create the pipes so we can read the output in real time as
-        # we execute the command.
-        stdout, stdout_writer = ::IO.pipe
-        stderr, stderr_writer = ::IO.pipe
-        process.io.stdout = stdout_writer
-        process.io.stderr = stderr_writer
-        process.duplex = true
-
-        # Special installer-related things
-        if Vagrant.in_installer?
-          installer_dir = ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"].to_s.downcase
-
-          # If we're in an installer on Mac and we're executing a command
-          # in the installer context, then force DYLD_LIBRARY_PATH to look
-          # at our libs first.
-          if Platform.darwin?
-            if @command[0].downcase.include?(installer_dir)
-              @logger.info("Command in the installer. Specifying DYLD_LIBRARY_PATH...")
-              process.environment["DYLD_LIBRARY_PATH"] =
-                "#{installer_dir}/lib:#{ENV["DYLD_LIBRARY_PATH"]}"
-            else
-              @logger.debug("Command not in installer, not touching env vars.")
-            end
-
-            if File.setuid?(@command[0]) || File.setgid?(@command[0])
-              @logger.info("Command is setuid/setgid, clearing DYLD_LIBRARY_PATH")
-              process.environment["DYLD_LIBRARY_PATH"] = ""
-            end
-          end
-
-          # If the command that is being run is not inside the installer, reset
-          # the original environment - this is required for shelling out to
-          # other subprocesses that depend on environment variables (like Ruby
-          # and $GEM_PATH for example)
-          internal = [installer_dir, Vagrant.user_data_path.to_s.downcase].
-            any? { |path| @command[0].downcase.include?(path) }
-          if !internal
-            @logger.info("Command not in installer, restoring original environment...")
-            jailbreak(process.environment)
-          end
-        else
-          @logger.info("Vagrant not running in installer, restoring original environment...")
-          jailbreak(process.environment)
-        end
-
-        # Set the environment on the process if we must
-        if @options[:env]
-          @options[:env].each do |k, v|
-            process.environment[k] = v
-          end
-        end
-
-        # Start the process
-        begin
-          SafeChdir.safe_chdir(workdir) do
-            process.start
-          end
-        rescue ChildProcess::LaunchError => ex
-          # Raise our own version of the error so that users of the class
-          # don't need to be aware of ChildProcess
-          raise LaunchError.new(ex.message)
-        end
-
-        # Make sure the stdin does not buffer
-        process.io.stdin.sync = true
-
-        if RUBY_PLATFORM != "java"
-          # On Java, we have to close after. See down the method...
-          # Otherwise, we close the writers right here, since we're
-          # not on the writing side.
-          stdout_writer.close
-          stderr_writer.close
-        end
-
-        # Create a dictionary to store all the output we see.
-        io_data = { stdout: "", stderr: "" }
-
-        # Record the start time for timeout purposes
-        start_time = Time.now.to_i
-
-        open_readers = [stdout, stderr]
-        open_writers = notify_stdin ? [process.io.stdin] : []
-        @logger.debug("Selecting on IO")
-        while true
-          results = ::IO.select(open_readers, open_writers, nil, 0.1)
-          results ||= []
-          readers = results[0]
-          writers = results[1]
-
-          # Check if we have exceeded our timeout
-          raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
-
-          # Check the readers to see if they're ready
-          if readers && !readers.empty?
-            readers.each do |r|
-              # Read from the IO object
-              data = IO.read_until_block(r)
-
-              # We don't need to do anything if the data is empty
-              next if data.empty?
-
-              io_name = r == stdout ? :stdout : :stderr
-              @logger.debug("#{io_name}: #{data.chomp}")
-
-              io_data[io_name] += data
-              yield io_name, data if block_given? && notify_table[io_name]
-            end
-          end
-
-          # Break out if the process exited. We have to do this before
-          # attempting to write to stdin otherwise we'll get a broken pipe
-          # error.
-          break if process.exited?
-
-          # Check the writers to see if they're ready, and notify any listeners
-          if writers && !writers.empty? && block_given?
-            yield :stdin, process.io.stdin
-
-            # if the callback closed stdin, we should remove it, because
-            # IO.select() will throw if called with a closed io.
-            if process.io.stdin.closed?
-              open_writers = []
-            end
-          end
-        end
-
-        # Wait for the process to end.
-        begin
-          remaining = (timeout || 32000) - (Time.now.to_i - start_time)
-          remaining = 0 if remaining < 0
-          @logger.debug("Waiting for process to exit. Remaining to timeout: #{remaining}")
-
-          process.poll_for_exit(remaining)
-        rescue ChildProcess::TimeoutError
-          raise TimeoutExceeded, process.pid
-        end
-
-        @logger.debug("Exit status: #{process.exit_code}")
-
-        # Read the final output data, since it is possible we missed a small
-        # amount of text between the time we last read data and when the
-        # process exited.
-        [stdout, stderr].each do |io|
-          # Read the extra data, ignoring if there isn't any
-          extra_data = IO.read_until_block(io)
-          next if extra_data == ""
-
-          # Log it out and accumulate
-          io_name = io == stdout ? :stdout : :stderr
-          io_data[io_name] += extra_data
-          @logger.debug("#{io_name}: #{extra_data.chomp}")
-
-          # Yield to any listeners any remaining data
-          yield io_name, extra_data if block_given? && notify_table[io_name]
-        end
-
-        if RUBY_PLATFORM == "java"
-          # On JRuby, we need to close the writers after the process,
-          # for some reason. See GH-711.
-          stdout_writer.close
-          stderr_writer.close
-        end
-
-        # Return an exit status container
-        return Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
-      ensure
-        if process && process.alive?
-          # Make sure no matter what happens, the process exits
-          process.stop(2)
-        end
-      end
-
-      protected
-
-      # An error which raises when a process fails to start
-      class LaunchError < StandardError; end
-
-      # An error which occurs when the process doesn't end within
-      # the given timeout.
-      class TimeoutExceeded < StandardError
-        attr_reader :pid
-
-        def initialize(pid)
-          super()
-          @pid = pid
-        end
-      end
-
-      # Container class to store the results of executing a subprocess.
-      class Result
-        attr_reader :exit_code
-        attr_reader :stdout
-        attr_reader :stderr
-
-        def initialize(exit_code, stdout, stderr)
-          @exit_code = exit_code
-          @stdout    = stdout
-          @stderr    = stderr
-        end
-      end
-
-      private
-
-      # This is, quite possibly, the saddest function in all of Vagrant.
-      #
-      # If a user is running Vagrant via Bundler (but not via the official
-      # installer), we want to reset to the "original" environment so that when
-      # shelling out to other Ruby processes (specifically), the original
-      # environment is restored. This is super important for things like
-      # rbenv and chruby, who rely on environment variables to locate gems, but
-      # Bundler stomps on those environment variables like an angry T-Rex after
-      # watching Jurassic Park 2 and realizing they replaced you with CGI.
-      #
-      # If a user is running in Vagrant via the official installer, BUT trying
-      # to execute a subprocess *outside* of the installer, we want to reset to
-      # the "original" environment. In this case, the Vagrant installer actually
-      # knows what the original environment was and replaces it completely.
-      #
-      # Finally, we reset any Bundler-specific environment variables, since the
-      # subprocess being called could, itself, be Bundler. And Bundler does not
-      # behave very nicely in these circumstances.
-      #
-      # This function was added in Vagrant 1.7.3, but there is a failsafe
-      # because the author doesn't trust himself that this functionality won't
-      # break existing assumptions, so users can specify
-      # `VAGRANT_SKIP_SUBPROCESS_JAILBREAK` and none of the above will happen.
-      #
-      # This function modifies the given hash in place!
-      #
-      # @return [nil]
-      def jailbreak(env = {})
-        return if ENV.key?("VAGRANT_SKIP_SUBPROCESS_JAILBREAK")
-
-        if defined?(::Bundler) && defined?(::Bundler::ORIGINAL_ENV)
-          env.replace(::Bundler::ORIGINAL_ENV)
-        end
-        env.merge!(Vagrant.original_env)
-
-        # Bundler does this, so I guess we should as well, since I think it
-        # other subprocesses that use Bundler will reload it
-        env["MANPATH"] = ENV["BUNDLE_ORIG_MANPATH"]
-
-        # Replace all current environment BUNDLE_ variables to nil
-        ENV.each do |k,_|
-          env[k] = nil if k[0,7] == "BUNDLE_"
-        end
-
-        # If RUBYOPT was set, unset it with Bundler
-        if ENV.key?("RUBYOPT")
-          env["RUBYOPT"] = ENV["RUBYOPT"].sub("-rbundler/setup", "")
-        end
-
-        nil
-      end
-    end
-  end
-end