vagrant 1.5.0 → 2.4.4

data/lib/vagrant/util/subprocess.rb

@@ -0,0 +1,365 @@
+# 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
+    # 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
+        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]
+          @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
+
+        # 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
+        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.trace("#{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.trace("#{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? && !@options[:detach]
+          # 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

data/lib/vagrant/util/template_renderer.rb

@@ -0,0 +1,91 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'ostruct'
+require "pathname"
+
+require 'erubi'
+
+module Vagrant
+  module Util
+    # This class is used to render the ERB templates in the
+    # `GEM_ROOT/templates` directory.
+    class TemplateRenderer < OpenStruct
+      class << self
+        # Render a given template and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @return [String] Rendered template
+        def render(*args)
+          render_with(:render, *args)
+        end
+
+        # Render a given string and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @param [String] template The template data string.
+        # @return [String] Rendered template
+        def render_string(*args)
+          render_with(:render_string, *args)
+        end
+
+        # Method used internally to DRY out the other renderers. This method
+        # creates and sets up the renderer before calling a specified method on it.
+        def render_with(method, template, data={})
+          renderer = new(template, data)
+          yield renderer if block_given?
+          renderer.send(method.to_sym)
+        end
+      end
+
+      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 instance as the binding. Because the
+      # renderer inherits from `OpenStruct`, additional view variables can be
+      # added like normal accessors.
+      #
+      # @return [String]
+      def render
+        old_template = template
+        result = nil
+        File.open(full_template_path, 'r') do |f|
+          self.template = f.read
+          result = render_string
+        end
+
+        result
+      ensure
+        self.template = old_template
+      end
+
+      # Renders a template, handling the template as a string, but otherwise
+      # acting the same way as {#render}.
+      #
+      # @return [String]
+      def render_string
+        binding.eval(Erubi::Engine.new(template, trim: true).src)
+      end
+
+      # 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
+        @template_root.join("#{template}.erb").to_s.squeeze("/")
+      end
+    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