vagrant 1.5.0 → 2.4.4

data/lib/vagrant/util/downloader.rb

@@ -0,0 +1,278 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "cgi"
+require "uri"
+
+require "log4r"
+require "digest"
+require "digest/md5"
+require "digest/sha1"
+require "vagrant/util/busy"
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+require "vagrant/util/curl_helper"
+require "vagrant/util/file_checksum"
+
+module Vagrant
+  module Util
+    # This class downloads 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 Downloader
+      # Custom user agent provided to cURL so that requests to URL shorteners
+      # are properly tracked.
+      #
+      #     Vagrant/1.7.4 (+https://www.vagrantup.com; ruby2.1.0)
+      USER_AGENT = "Vagrant/#{VERSION} (+https://www.vagrantup.com; #{RUBY_ENGINE}#{RUBY_VERSION}) #{ENV['VAGRANT_USER_AGENT_PROVISIONAL_STRING']}".strip.freeze
+
+      attr_accessor :source
+      attr_reader :destination
+      attr_accessor :headers
+
+      def initialize(source, destination, options=nil)
+        options     ||= {}
+
+        @logger      = Log4r::Logger.new("vagrant::util::downloader")
+        @source      = source.to_s
+        @destination = destination.to_s
+
+        begin
+          url = URI.parse(@source)
+          if url.scheme && url.scheme.start_with?("http") && url.user
+            auth = "#{CGI.unescape(url.user)}"
+            auth += ":#{CGI.unescape(url.password)}" if url.password
+            url.user = nil
+            url.password = nil
+            options[:auth] ||= auth
+            @source = url.to_s
+          end
+        rescue URI::InvalidURIError
+          # Ignore, since its clearly not HTTP
+        end
+
+        # Get the various optional values
+        @auth        = options[:auth]
+        @ca_cert     = options[:ca_cert]
+        @ca_path     = options[:ca_path]
+        @continue    = options[:continue]
+        @headers     = Array(options[:headers])
+        @insecure    = options[:insecure]
+        @ui          = options[:ui]
+        @client_cert = options[:client_cert]
+        @location_trusted = options[:location_trusted]
+        @checksums   = {
+          :md5 => options[:md5],
+          :sha1 => options[:sha1],
+          :sha256 => options[:sha256],
+          :sha384 => options[:sha384],
+          :sha512 => options[:sha512]
+        }.compact
+        @extra_download_options = options[:box_extra_download_options] || []
+        # If on Windows SSL revocation checks should be best effort. More context
+        # for this usage can be found in the following links:
+        #
+        # https://github.com/curl/curl/issues/3727
+        # https://github.com/curl/curl/pull/4981
+        if Platform.windows?
+          @ssl_revoke_best_effort = !options[:disable_ssl_revoke_best_effort]
+        end
+      end
+
+      # This executes the actual download, downloading the source file
+      # to the destination with the given options used to initialize this
+      # class.
+      #
+      # If this method returns without an exception, the download
+      # succeeded. An exception will be raised if the download failed.
+      def download!
+        # This variable can contain the proc that'll be sent to
+        # the subprocess execute.
+        data_proc = nil
+
+        extra_subprocess_opts = {}
+        if @ui
+          # If we're outputting progress, then setup the subprocess to
+          # tell us output so we can parse it out.
+          extra_subprocess_opts[:notify] = :stderr
+
+          data_proc = Vagrant::Util::CurlHelper.capture_output_proc(@logger, @ui, @source)
+        end
+
+        @logger.info("Downloader starting download: ")
+        @logger.info("  -- Source: #{@source}")
+        @logger.info("  -- Destination: #{@destination}")
+
+        retried = false
+        begin
+          # Get the command line args and the subprocess opts based
+          # on our downloader settings.
+          options, subprocess_options = self.options
+          options += ["--output", @destination]
+          options << @source
+
+          # Merge in any extra options we set
+          subprocess_options.merge!(extra_subprocess_opts)
+
+          # Go!
+          execute_curl(options, subprocess_options, &data_proc)
+        rescue Errors::DownloaderError => e
+          # If we already retried, raise it.
+          raise if retried
+
+          @logger.error("Exit code: #{e.extra_data[:code]}")
+
+          # If its any error other than 33, it is an error.
+          raise if e.extra_data[:code].to_i != 33
+
+          # Exit code 33 means that the server doesn't support ranges.
+          # In this case, try again without resume.
+          @logger.error("Error is server doesn't support byte ranges. Retrying from scratch.")
+          @continue = false
+          retried = true
+          retry
+        ensure
+          # If we're outputting to the UI, clear the output to
+          # avoid lingering progress meters.
+          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
+        end
+
+        validate_download!(@source, @destination, @checksums)
+
+        # Everything succeeded
+        true
+      end
+
+      # Does a HEAD request of the URL and returns the output.
+      def head
+        options, subprocess_options = self.options
+        options.unshift("-I")
+        options << @source
+
+        @logger.info("HEAD: #{@source}")
+        result = execute_curl(options, subprocess_options)
+        result.stdout
+      end
+
+      protected
+
+      # Apply any checksum validations based on provided
+      # options content
+      #
+      # @param source [String] Source of file
+      # @param path [String, Pathname] local file path
+      # @param checksums [Hash] User provided options
+      # @option checksums [String] :md5 Compare MD5 checksum
+      # @option checksums [String] :sha1 Compare SHA1 checksum
+      # @return [Boolean]
+      def validate_download!(source, path, checksums)
+        checksums.each do |type, expected|
+          actual = FileChecksum.new(path, type).checksum
+          @logger.debug("Validating checksum (#{type}) for #{source}. " \
+            "expected: #{expected} actual: #{actual}")
+          if actual.casecmp(expected) != 0
+            raise Errors::DownloaderChecksumError.new(
+              source: source,
+              path: path,
+              type: type,
+              expected_checksum: expected,
+              actual_checksum: actual
+            )
+          end
+        end
+        true
+      end
+
+      def execute_curl(options, subprocess_options, &data_proc)
+        options = options.dup
+        options.unshift("-q")
+        options << subprocess_options
+
+        # Create the callback that is called if we are interrupted
+        interrupted  = false
+        int_callback = Proc.new do
+          @logger.info("Downloader interrupted!")
+          interrupted = true
+        end
+
+        # Execute!
+        result = Busy.busy(int_callback) do
+          Subprocess.execute("curl", *options, &data_proc)
+        end
+
+        # If the download was interrupted, then raise a specific error
+        raise Errors::DownloaderInterrupted 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("Downloader exit code: #{result.exit_code}")
+          check = result.stderr.match(/\n*curl:\s+\((?<code>\d+)\)\s*(?<error>.*)$/)
+          if check && check[:code] == "416"
+            # All good actually. 416 means there is no more bytes to download
+            @logger.warn("Downloader got a 416, but is likely fine. Continuing on...")
+          else
+            if !check
+              err_msg = result.stderr
+            else
+              err_msg = check[:error]
+            end
+
+            raise Errors::DownloaderError,
+              code: result.exit_code,
+              message: err_msg
+          end
+        end
+
+        result
+      end
+
+      # Returns the various cURL and subprocess options.
+      #
+      # @return [Array<Array, Hash>]
+      def options
+        # Build the list of parameters to execute with cURL
+        options = [
+          "--fail",
+          "--location",
+          "--max-redirs", "10", "--verbose",
+          "--user-agent", USER_AGENT,
+        ]
+
+        options += ["--cacert", @ca_cert] if @ca_cert
+        options += ["--capath", @ca_path] if @ca_path
+        options += ["--continue-at", "-"] if @continue
+        options << "--insecure" if @insecure
+        options << "--cert" << @client_cert if @client_cert
+        options << "-u" << @auth if @auth
+        options << "--location-trusted" if @location_trusted
+        options << "--ssl-revoke-best-effort" if @ssl_revoke_best_effort
+
+        options.concat(@extra_download_options)
+
+        if @headers
+          Array(@headers).each do |header|
+            options << "-H" << header
+          end
+        end
+
+        # Specify some options for the subprocess
+        subprocess_options = {}
+
+        # If we're in Vagrant, then we use the packaged CA bundle
+        if Vagrant.in_installer?
+          subprocess_options[:env] ||= {}
+          subprocess_options[:env]["CURL_CA_BUNDLE"] = ENV["CURL_CA_BUNDLE"]
+        end
+
+        return [options, subprocess_options]
+      end
+    end
+  end
+end

data/lib/vagrant/util/env.rb

@@ -0,0 +1,56 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    class Env
+      def self.with_original_env
+        original_env = ENV.to_hash
+        if defined?(::Bundler) && defined?(::Bundler::ORIGINAL_ENV)
+          ENV.replace(::Bundler::ORIGINAL_ENV)
+        end
+        ENV.update(Vagrant.original_env)
+        yield
+      ensure
+        ENV.replace(original_env.to_hash)
+      end
+
+      # Execute the given command, removing any Ruby-specific environment
+      # variables. This is an "enhanced" version of `Bundler.with_clean_env`,
+      # which only removes Bundler-specific values. We need to remove all
+      # values, specifically:
+      #
+      # - _ORIGINAL_GEM_PATH
+      # - GEM_PATH
+      # - GEM_HOME
+      # - GEM_ROOT
+      # - BUNDLE_BIN_PATH
+      # - BUNDLE_GEMFILE
+      # - RUBYLIB
+      # - RUBYOPT
+      # - RUBY_ENGINE
+      # - RUBY_ROOT
+      # - RUBY_VERSION
+      #
+      # This will escape Vagrant's environment entirely, which is required if
+      # calling an executable that lives in another Ruby environment. The
+      # original environment restored at the end of this call.
+      #
+      # @param [Proc] block
+      #   the block to execute with the cleaned environment
+      def self.with_clean_env
+        with_original_env do
+          if ENV["BUNDLE_ORIG_MANPATH"]
+            ENV["MANPATH"] = ENV["BUNDLE_ORIG_MANPATH"]
+          end
+          ENV.delete_if { |k,_| k[0,7] == "BUNDLE_" }
+          if ENV.has_key? "RUBYOPT"
+            ENV["RUBYOPT"] = ENV["RUBYOPT"].sub("-rbundler/setup", "")
+            ENV["RUBYOPT"] = ENV["RUBYOPT"].sub("-I#{File.expand_path('..', __FILE__)}", "")
+          end
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/experimental.rb

@@ -0,0 +1,79 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    class Experimental
+      class << self
+        # A method for determining if the experimental flag has been enabled with
+        # any features
+        #
+        # @return [Boolean]
+        def enabled?
+          if !defined?(@_experimental)
+            experimental = features_requested
+            if experimental.size >= 1 && experimental.first != "0"
+              @_experimental = true
+            else
+              @_experimental = false
+            end
+          end
+          @_experimental
+        end
+
+        # A method for determining if all experimental features have been enabled
+        # by either a global enabled value "1" or all features explicitly enabled.
+        #
+        # @return [Boolean]
+        def global_enabled?
+          if !defined?(@_global_enabled)
+            experimental = features_requested
+            if experimental.size == 1 && experimental.first == "1"
+              @_global_enabled = true
+            else
+              @_global_enabled = false
+            end
+          end
+          @_global_enabled
+        end
+
+        # A method for Vagrant internals to determine if a given feature
+        # has been abled by the user, is a valid feature flag and can be used.
+        #
+        # @param [String] feature
+        # @return [Boolean] - A hash containing the original array and if it is valid
+        def feature_enabled?(feature)
+          experimental = features_requested
+          feature = feature.to_s
+
+          return global_enabled? || experimental.include?(feature)
+        end
+
+        # Returns the features requested for the experimental flag
+        #
+        # @return [Array] - Returns an array of requested experimental features
+        def features_requested
+          if !defined?(@_requested_features)
+            @_requested_features = ENV["VAGRANT_EXPERIMENTAL"].to_s.downcase.split(',')
+          end
+          @_requested_features
+        end
+
+        # A function to guard experimental blocks of code from being executed
+        #
+        # @param [Array] features - Array of features to guard a method with
+        # @param [Block] block - Block of ruby code to be guarded against
+        def guard_with(*features, &block)
+          yield if block_given? && features.any? {|f| feature_enabled?(f)}
+        end
+
+        # @private
+        # Reset the cached values for platform. This is not considered a public
+        # API and should only be used for testing.
+        def reset!
+          instance_variables.each(&method(:remove_instance_variable))
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/file_checksum.rb

@@ -0,0 +1,77 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+# This is an "interface" that should be implemented by any digest class
+# passed into FileChecksum. Note that this isn't strictly enforced at
+# the moment, and this class isn't directly used. It is merely here for
+# documentation of structure of the class.
+
+require "vagrant/errors"
+
+class DigestClass
+  def update(string); end
+  def hexdigest; end
+end
+
+class FileChecksum
+  BUFFER_SIZE = 1024 * 8
+
+  # Supported file checksum
+  CHECKSUM_MAP = {
+    :md5 => Digest::MD5,
+    :sha1 => Digest::SHA1,
+    :sha256 => Digest::SHA256,
+    :sha384 => Digest::SHA384,
+    :sha512 => Digest::SHA512
+  }.freeze
+
+  # Initializes an object to calculate the checksum of a file. The given
+  # ``digest_klass`` should implement the ``DigestClass`` interface. Note
+  # that the built-in Ruby digest classes duck type this properly:
+  # Digest::MD5, Digest::SHA1, etc.
+  def initialize(path, digest_klass)
+    if digest_klass.is_a?(Class)
+      @digest_klass = digest_klass
+    else
+      @digest_klass = load_digest(digest_klass)
+    end
+
+    @path = path
+  end
+
+  # This calculates the checksum of the file and returns it as a
+  # string.
+  #
+  # @return [String]
+  def checksum
+    digest = @digest_klass.new
+    buf = ''
+
+    File.open(@path, "rb") do |f|
+      while !f.eof
+        begin
+          f.readpartial(BUFFER_SIZE, buf)
+          digest.update(buf)
+        rescue EOFError
+          # Although we check for EOF earlier, this seems to happen
+          # sometimes anyways [GH-2716].
+          break
+        end
+      end
+    end
+
+    digest.hexdigest
+  end
+
+  private
+
+  def load_digest(type)
+    digest = CHECKSUM_MAP[type.to_s.downcase.to_sym]
+    if digest.nil?
+      raise Vagrant::Errors::BoxChecksumInvalidType,
+        type: type.to_s,
+        types: CHECKSUM_MAP.keys.join(', ')
+    end
+    digest
+  end
+end

data/lib/vagrant/util/file_mode.rb

@@ -0,0 +1,15 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    class FileMode
+      # This returns the file permissions as a string from
+      # an octal number.
+      def self.from_octal(octal)
+        perms = sprintf("%o", octal)
+        perms.reverse[0..2].reverse
+      end
+    end
+  end
+end

data/lib/vagrant/util/file_mutex.rb

@@ -0,0 +1,50 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # Utility to provide a simple mutex via file lock
+    class FileMutex
+      # Create a new FileMutex instance
+      #
+      # @param mutex_path [String] path for file
+      def initialize(mutex_path)
+        @mutex_path = mutex_path
+      end
+
+      # Execute provided block within lock and unlock
+      # when completed
+      def with_lock(&block)
+        lock
+        begin
+          block.call
+        rescue => e
+          raise e
+        ensure
+          unlock
+        end
+      end
+
+      # Attempt to acquire the lock
+      def lock
+        if lock_file.flock(File::LOCK_EX|File::LOCK_NB) === false
+          raise Errors::VagrantLocked, lock_file_path: @mutex_path
+        end
+      end
+
+      # Unlock the file
+      def unlock
+        lock_file.flock(File::LOCK_UN)
+        lock_file.close
+        File.delete(@mutex_path) if File.file?(@mutex_path)
+      end
+
+      protected
+
+      def lock_file
+        return @lock_file if @lock_file && !@lock_file.closed?
+        @lock_file = File.open(@mutex_path, "w+")
+      end
+    end
+  end
+end

data/lib/vagrant/util/guest_hosts.rb

@@ -0,0 +1,71 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # Helper methods for modfiying guests /etc/hosts file
+    module GuestHosts
+
+      module Unix
+        DEAFAULT_LOOPBACK_CHECK_LIMIT = 5.freeze
+
+        # Add hostname to a loopback address on /etc/hosts if not already there
+        # Will insert name at the first free address of the form 127.0.X.1, up to
+        # the loop_bound
+        #
+        # @param [Communicator] 
+        # @param [String] full hostanme
+        # @param [int] (option) defines the upper bound for searching for an available loopback address
+        def add_hostname_to_loopback_interface(comm, name, loop_bound=DEAFAULT_LOOPBACK_CHECK_LIMIT)
+          basename = name.split(".", 2)[0]
+          comm.sudo <<-EOH.gsub(/^ {14}/, '')
+          grep -w '#{name}' /etc/hosts || {
+            for i in #{[*1..loop_bound].join(' ')}; do
+              grep -w "127.0.${i}.1" /etc/hosts || {
+                echo "127.0.${i}.1 #{name} #{basename}" >> /etc/hosts
+                break
+              }
+            done
+          }
+          EOH
+        end
+      end
+
+      # Linux specific inspection helpers
+      module Linux
+        include Unix
+        # Remove any line in /etc/hosts that contains hostname,
+        # then add hostname with associated ip 
+        #
+        # @param [Communicator] 
+        # @param [String] full hostanme
+        # @param [String] target ip
+        def replace_host(comm, name, ip)
+          basename = name.split(".", 2)[0]
+          comm.sudo <<-EOH.gsub(/^ {14}/, '')
+          sed -i '/#{name}/d' /etc/hosts
+          sed -i'' '1i '#{ip}'\\t#{name}\\t#{basename}' /etc/hosts
+          EOH
+        end
+      end
+
+      # BSD specific inspection helpers
+      module BSD
+        include Unix
+        # Remove any line in /etc/hosts that contains hostname,
+        # then add hostname with associated ip 
+        #
+        # @param [Communicator] 
+        # @param [String] full hostanme
+        # @param [String] target ip
+        def replace_host(comm, name, ip)
+          basename = name.split(".", 2)[0]
+          comm.sudo <<-EOH.gsub(/^ {14}/, '')
+          sed -i.bak '/#{name}/d' /etc/hosts
+          sed -i.bak '1i\\\n#{ip}\t#{name}\t#{basename}\n' /etc/hosts
+          EOH
+        end
+      end
+    end
+  end
+end