vagrant 1.0.7 → 2.4.4

data/lib/vagrant/util/subprocess.rb

@@ -1,7 +1,15 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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
@@ -12,9 +20,6 @@ module Vagrant
     # from the subprocess in real time, by simply passing a block to
     # the execute method.
     class Subprocess
-      # The chunk size for reading from subprocess IO.
-      READ_CHUNK_SIZE = 4096
-
       # Convenience method for executing a method.
       def self.execute(*command, &block)
         new(*command).execute(&block)
@@ -22,26 +27,123 @@ module Vagrant
 
       def initialize(*command)
         @options = command.last.is_a?(Hash) ? command.pop : {}
-        @command = command
+        @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 = ChildProcess.build(*@command)
+        @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
+        stdout, stdout_writer = ::IO.pipe
+        stderr, stderr_writer = ::IO.pipe
         process.io.stdout = stdout_writer
         process.io.stderr = stderr_writer
         process.duplex = true
+        process.leader = true if @options[:detach]
+        process.detach = true if @options[:detach]
+
+        # Special installer-related things
+        if Vagrant.in_installer?
+          installer_dir = 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
+
+          # If running within an AppImage and calling external executable. When
+          # executable is external set the LD_LIBRARY_PATH to host values.
+          if ENV["VAGRANT_APPIMAGE"]
+            embed_path = Pathname.new(Vagrant.installer_embedded_dir).expand_path.to_s
+            exec_path = Pathname.new(@command[0]).expand_path.to_s
+            if !exec_path.start_with?(embed_path) && ENV["VAGRANT_APPIMAGE_HOST_LD_LIBRARY_PATH"]
+              @logger.info("Detected AppImage environment and request to external binary. Updating library path.")
+              @logger.debug("Setting LD_LIBRARY_PATH to #{ENV["VAGRANT_APPIMAGE_HOST_LD_LIBRARY_PATH"]}")
+              process.environment["LD_LIBRARY_PATH"] = ENV["VAGRANT_APPIMAGE_HOST_LD_LIBRARY_PATH"].to_s
+            end
+          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]
@@ -52,13 +154,19 @@ module Vagrant
 
         # Start the process
         begin
-          Dir.chdir(workdir) do
+          SafeChdir.safe_chdir(workdir) do
             process.start
           end
-        rescue ChildProcess::LaunchError
+        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
+          raise LaunchError.new(ex.message)
+        end
+
+        # If running with the detach option, no need to capture IO or
+        # ensure program exists.
+        if @options[:detach]
+          return
         end
 
         # Make sure the stdin does not buffer
@@ -73,33 +181,37 @@ module Vagrant
         end
 
         # Create a dictionary to store all the output we see.
-        io_data = { :stdout => "", :stderr => "" }
+        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([stdout, stderr], [process.io.stdin], nil, timeout || 5)
-          readers, writers = results
+          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.empty?
+          if readers && !readers.empty?
             readers.each do |r|
               # Read from the IO object
-              data = read_io(r)
+              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}")
+              @logger.trace("#{io_name}: #{data.chomp}")
 
               io_data[io_name] += data
-              yield io_name, data if block_given?
+              yield io_name, data if block_given? && notify_table[io_name]
             end
           end
 
@@ -109,8 +221,14 @@ module Vagrant
           break if process.exited?
 
           # Check the writers to see if they're ready, and notify any listeners
-          if !writers.empty?
-            yield :stdin, process.io.stdin if block_given?
+          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
 
@@ -132,16 +250,16 @@ module Vagrant
         # process exited.
         [stdout, stderr].each do |io|
           # Read the extra data, ignoring if there isn't any
-          extra_data = read_io(io)
+          extra_data = IO.read_until_block(io)
           next if extra_data == ""
 
           # Log it out and accumulate
-          @logger.debug(extra_data)
           io_name = io == stdout ? :stdout : :stderr
           io_data[io_name] += extra_data
+          @logger.trace("#{io_name}: #{extra_data.chomp}")
 
           # Yield to any listeners any remaining data
-          yield io_name, extra_data if block_given?
+          yield io_name, extra_data if block_given? && notify_table[io_name]
         end
 
         if RUBY_PLATFORM == "java"
@@ -153,69 +271,15 @@ module Vagrant
 
         # Return an exit status container
         return Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
+      ensure
+        if process && process.alive? && !@options[:detach]
+          # Make sure no matter what happens, the process exits
+          process.stop(2)
+        end
       end
 
       protected
 
-      # Reads data from an IO object while it can, returning the data it reads.
-      # When it encounters a case when it can't read anymore, it returns the
-      # data.
-      #
-      # @return [String]
-      def read_io(io)
-        data = ""
-
-        while true
-          begin
-            if Platform.windows?
-              # Windows doesn't support non-blocking reads on
-              # file descriptors or pipes so we have to get
-              # a bit more creative.
-
-              # Check if data is actually ready on this IO device.
-              # We have to do this since `readpartial` will actually block
-              # until data is available, which can cause blocking forever
-              # in some cases.
-              results = IO.select([io], nil, nil, 1)
-              break if !results || results[0].empty?
-
-              # Read!
-              data << io.readpartial(READ_CHUNK_SIZE)
-            else
-              # Do a simple non-blocking read on the IO object
-              data << io.read_nonblock(READ_CHUNK_SIZE)
-            end
-          rescue Exception => e
-            # The catch-all rescue here is to support multiple Ruby versions,
-            # since we use some Ruby 1.9 specific exceptions.
-
-            breakable = false
-            if e.is_a?(EOFError)
-              # An `EOFError` means this IO object is done!
-              breakable = true
-            elsif defined?(IO::WaitReadable) && e.is_a?(IO::WaitReadable)
-              # IO::WaitReadable is only available on Ruby 1.9+
-
-              # An IO::WaitReadable means there may be more IO but this
-              # IO object is not ready to be read from yet. No problem,
-              # we read as much as we can, so we break.
-              breakable = true
-            elsif e.is_a?(Errno::EAGAIN)
-              # Otherwise, we just look for the EAGAIN error which should be
-              # all that IO::WaitReadable does in Ruby 1.9.
-              breakable = true
-            end
-
-            # Break out if we're supposed to. Otherwise re-raise the error
-            # because it is a real problem.
-            break if breakable
-            raise
-          end
-        end
-
-        data
-      end
-
       # An error which raises when a process fails to start
       class LaunchError < StandardError; end
 
@@ -242,6 +306,60 @@ module Vagrant
           @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

data/lib/vagrant/util/template_renderer.rb

@@ -1,5 +1,10 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
 require 'ostruct'
-require 'erubis'
+require "pathname"
+
+require 'erubi'
 
 module Vagrant
   module Util
@@ -38,19 +43,22 @@ module Vagrant
       def initialize(template, data = {})
         super()
 
+        @template_root = data.delete(:template_root)
+        @template_root ||= Vagrant.source_root.join("templates")
+        @template_root = Pathname.new(@template_root)
+
         data[:template] = template
         data.each do |key, value|
           send("#{key}=", value)
         end
       end
 
-      # Renders the template using the class intance as the binding. Because the
+      # Renders the template using the class instance as the binding. Because the
       # renderer inherits from `OpenStruct`, additional view variables can be
       # added like normal accessors.
       #
       # @return [String]
       def render
-        # TODO: Seems like a pretty dirty way to do this. Perhaps refactor this
         old_template = template
         result = nil
         File.open(full_template_path, 'r') do |f|
@@ -68,15 +76,15 @@ module Vagrant
       #
       # @return [String]
       def render_string
-        Erubis::Eruby.new(template, :trim => true).result(binding)
+        binding.eval(Erubi::Engine.new(template, trim: true).src)
       end
 
-      # Returns the full path to the template, taking into accoun the gem directory
+      # Returns the full path to the template, taking into account the gem directory
       # and adding the `.erb` extension to the end.
       #
       # @return [String]
       def full_template_path
-        Vagrant.source_root.join('templates', "#{template}.erb").to_s.squeeze("/")
+        @template_root.join("#{template}.erb").to_s.squeeze("/")
       end
     end
   end

data/lib/vagrant/util/uploader.rb

@@ -0,0 +1,109 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "uri"
+
+require "log4r"
+require "vagrant/util/busy"
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+require "vagrant/util/curl_helper"
+
+module Vagrant
+  module Util
+    # This class uploads files using various protocols by subprocessing
+    # to cURL. cURL is a much more capable and complete download tool than
+    # a hand-rolled Ruby library, so we defer to its expertise.
+    class Uploader
+
+      # @param [String] destination Valid URL to upload file to
+      # @param [String] file Location of file to upload on disk
+      # @param [Hash] options
+      # @option options [Vagrant::UI] :ui UI interface for output
+      # @option options [String, Symbol] :method Request method for upload
+      def initialize(destination, file, options=nil)
+        options ||= {}
+        @logger         = Log4r::Logger.new("vagrant::util::uploader")
+        @destination    = destination.to_s
+        @file           = file.to_s
+        @ui             = options[:ui]
+        @request_method = options[:method]
+
+        if !@request_method
+          @request_method = "PUT"
+        end
+        @request_method = @request_method.to_s.upcase
+      end
+
+      def upload!
+        data_proc = Vagrant::Util::CurlHelper.capture_output_proc(@logger, @ui)
+
+        @logger.info("Uploader starting upload: ")
+        @logger.info("  -- Source: #{@file}")
+        @logger.info("  -- Destination: #{@destination}")
+
+        options = build_options
+        subprocess_options = {notify: :stderr}
+
+        begin
+          execute_curl(options, subprocess_options, &data_proc)
+        rescue Errors::UploaderError => e
+          raise
+        ensure
+          @ui.clear_line if @ui
+        end
+      end
+
+      protected
+
+      def build_options
+        options = [@destination, "--request", @request_method, "--upload-file", @file, "--fail"]
+        return options
+      end
+
+      def execute_curl(options, subprocess_options, &data_proc)
+        options = options.dup
+        options << subprocess_options
+
+        # Create the callback that is called if we are interrupted
+        interrupted  = false
+        int_callback = Proc.new do
+          @logger.info("Uploader interrupted!")
+          interrupted = true
+        end
+
+        # Execute!
+        result = Busy.busy(int_callback) do
+          Subprocess.execute("curl", *options, &data_proc)
+        end
+
+        # If the upload was interrupted, then raise a specific error
+        raise Errors::UploaderInterrupted if interrupted
+
+        # If it didn't exit successfully, we need to parse the data and
+        # show an error message.
+        if result.exit_code != 0
+          @logger.warn("Uploader exit code: #{result.exit_code}")
+          check = result.stderr.match(/\n*curl:\s+\((?<code>\d+)\)\s*(?<error>.*)$/)
+          if !check
+            err_msg = result.stderr
+          else
+            err_msg = check[:error]
+          end
+
+          raise Errors::UploaderError,
+            exit_code: result.exit_code,
+            message: err_msg
+        end
+
+        if @ui
+          @ui.clear_line
+          # Windows doesn't clear properly for some reason, so we just
+          # output one more newline.
+          @ui.detail("") if Platform.windows?
+        end
+        result
+      end
+    end
+  end
+end

data/lib/vagrant/util/which.rb

@@ -0,0 +1,56 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/util/platform"
+
+module Vagrant
+  module Util
+    class Which
+      # Cross-platform way of finding an executable in the PATH.
+      #
+      #   which('ruby') #=> /usr/bin/ruby
+      #
+      # This code is adapted from the following post by mislav:
+      #   http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+      #
+      # @param [String] cmd The command to search for in the PATH.
+      # @param [Hash] opts Optional flags
+      #   @option [Boolean] :original_path Search within original path if available
+      # @return [String] The full path to the executable or `nil` if not found.
+      def self.which(cmd, **opts)
+        exts = nil
+
+        if !Platform.windows? || ENV['PATHEXT'].nil?
+          # If the PATHEXT variable is empty, we're on *nix and need to find
+          # the exact filename
+          exts = ['']
+        elsif File.extname(cmd).length != 0
+          # On Windows: if filename contains an extension, we must match that
+          # exact filename
+          exts = ['']
+        else
+          # On Windows: otherwise try to match all possible executable file
+          # extensions (.EXE .COM .BAT etc.)
+          exts = ENV['PATHEXT'].split(';')
+        end
+
+        if opts[:original_path]
+          search_path = ENV.fetch('VAGRANT_OLD_ENV_PATH', ENV['PATH'])
+        else
+          search_path = ENV['PATH']
+        end
+
+        SilenceWarnings.silence! do
+          search_path.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '').split(File::PATH_SEPARATOR).each do |path|
+            exts.each do |ext|
+              exe = "#{path}#{File::SEPARATOR}#{cmd}#{ext}"
+              return exe if File.executable? exe
+            end
+          end
+        end
+
+        return nil
+      end
+    end
+  end
+end

data/lib/vagrant/util/windows_path.rb

@@ -0,0 +1,41 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fiddle/import"
+
+module Vagrant
+  module Util
+    module WindowsPath
+      module API
+        extend Fiddle::Importer
+        dlload 'kernel32.dll'
+        extern("int GetLongPathNameA(char*, char*, int)", :stdcall)
+      end
+
+      # Converts a Windows shortname to a long name. This only works
+      # for ASCII paths currently and doesn't use the wide character
+      # support.
+      def self.longname(name)
+        # We loop over the API call in case we didn't allocate enough
+        # buffer space. In general it is usually enough.
+        bufferlen = 250
+        buffer    = nil
+        while true
+          buffer = ' ' * bufferlen
+          len    = API.GetLongPathNameA(name.to_s, buffer, buffer.size)
+          if bufferlen < len
+            # If the length returned is larger than our buffer length,
+            # it is the API telling us it needs more space. Allocate it
+            # and retry.
+            bufferlen = len
+            continue
+          end
+
+          break
+        end
+
+        return buffer.rstrip.chomp("\0")
+      end
+    end
+  end
+end