vagrant 1.5.0 → 2.4.4

data/lib/vagrant/util/busy.rb

@@ -0,0 +1,62 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # Utility class which allows blocks of code to be marked as "busy"
+    # with a specified interrupt handler. During busy areas of code, it
+    # is often undesirable for SIGINTs to immediately kill the application.
+    # This class is a helper to cleanly register callbacks to handle this
+    # situation.
+    class Busy
+      @@registered = []
+      @@mutex = Mutex.new
+
+      class << self
+        # Mark a given block of code as a "busy" block of code, which will
+        # register a SIGINT handler for the duration of the block. When a
+        # SIGINT occurs, the `sig_callback` proc will be called. It is up
+        # to the callback to behave properly and exit the application.
+        def busy(sig_callback)
+          register(sig_callback)
+          return yield
+        ensure
+          unregister(sig_callback)
+        end
+
+        # Registers a SIGINT handler. This typically is called from {busy}.
+        # Callbacks are only registered once, so calling this multiple times
+        # with the same callback has no consequence.
+        def register(sig_callback)
+          @@mutex.synchronize do
+            registered << sig_callback
+            registered.uniq!
+
+            # Register the handler if this is our first callback.
+            Signal.trap("INT") { fire_callbacks } if registered.length == 1
+          end
+        end
+
+        # Unregisters a SIGINT handler.
+        def unregister(sig_callback)
+          @@mutex.synchronize do
+            registered.delete(sig_callback)
+
+            # Remove the signal trap if no more registered callbacks exist
+            Signal.trap("INT", "DEFAULT") if registered.empty?
+          end
+        end
+
+        # Fires all the registered callbacks.
+        def fire_callbacks
+          registered.reverse.each { |r| r.call }
+        end
+
+        # Helper method to get access to the class variable. This is mostly
+        # exposed for tests. This shouldn't be mucked with directly, since it's
+        # structure may change at any time.
+        def registered; @@registered; end
+      end
+    end
+  end
+end

data/lib/vagrant/util/caps.rb

@@ -0,0 +1,51 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "tempfile"
+require "fileutils"
+require "pathname"
+require "vagrant/util/directory"
+require "vagrant/util/subprocess"
+
+module Vagrant
+  module Util
+    module Caps
+      module BuildISO
+
+        # Builds an iso given a compatible iso_command
+        #
+        # @param [List<String>] command to build iso
+        # @param [Pathname] input directory for iso build
+        # @param [Pathname] output file for iso build
+        def build_iso(iso_command, source_directory, file_destination)
+          FileUtils.mkdir_p(file_destination.dirname)
+          if !file_destination.exist? || Vagrant::Util::Directory.directory_changed?(source_directory, file_destination.mtime)
+            result = Vagrant::Util::Subprocess.execute(*iso_command)
+            if result.exit_code != 0
+              raise Vagrant::Errors::ISOBuildFailed, cmd: iso_command.join(" "), stdout: result.stdout, stderr: result.stderr
+            end
+          end
+        end
+
+        protected
+
+        def ensure_output_iso(file_destination)
+          if file_destination.nil?
+            tmpfile = Tempfile.new(["vagrant", ".iso"])
+            file_destination = Pathname.new(tmpfile.path)
+            tmpfile.close
+            tmpfile.unlink
+          else
+            file_destination = Pathname.new(file_destination.to_s)
+            # If the file destination path is a folder, target the output to a randomly named
+            # file in that dir
+            if file_destination.extname != ".iso"
+              file_destination = file_destination.join("#{SecureRandom.hex(3)}_vagrant.iso")
+            end
+          end
+          file_destination
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/checkpoint_client.rb

@@ -0,0 +1,186 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+require "singleton"
+
+module Vagrant
+  module Util
+    class CheckpointClient
+
+      include Singleton
+
+      # Maximum number of seconds to wait for check to complete
+      CHECKPOINT_TIMEOUT = 10
+
+      # @return [Log4r::Logger]
+      attr_reader :logger
+
+      # @return [Boolean]
+      attr_reader :enabled
+
+      # @return [Hash]
+      attr_reader :files
+
+      # @return [Vagrant::Environment]
+      attr_reader :env
+
+      def initialize
+        @logger = Log4r::Logger.new("vagrant::checkpoint_client")
+        @enabled = false
+      end
+
+      # Setup will attempt to load the checkpoint library and define
+      # required paths
+      #
+      # @param [Vagrant::Environment] env
+      # @return [self]
+      def setup(env)
+        begin
+          require "checkpoint"
+          @enabled = true
+        rescue LoadError
+          @logger.warn("checkpoint library not found. disabling.")
+        end
+        if ENV["VAGRANT_CHECKPOINT_DISABLE"]
+          @logger.debug("checkpoint disabled via explicit user request")
+          @enabled = false
+        end
+        @files = {
+          signature: env.data_dir.join("checkpoint_signature"),
+          cache: env.data_dir.join("checkpoint_cache")
+        }
+        @checkpoint_thread = nil
+        @env = env
+        self
+      end
+
+      # Check has completed
+      def complete?
+        !@checkpoint_thread.nil? && !@checkpoint_thread.alive?
+      end
+
+      # Result of check
+      #
+      # @return [Hash, nil]
+      def result
+        if !enabled || @checkpoint_thread.nil?
+          nil
+        elsif !defined?(@result)
+          @checkpoint_thread.join(CHECKPOINT_TIMEOUT)
+          @result = @checkpoint_thread[:result]
+        else
+          @result
+        end
+      end
+
+      # Run check
+      #
+      # @return [self]
+      def check
+        if enabled && @checkpoint_thread.nil?
+          logger.debug("starting plugin check")
+          @checkpoint_thread = Thread.new do
+            Thread.current.abort_on_exception = false
+            if Thread.current.respond_to?(:report_on_exception=)
+              Thread.current.report_on_exception = false
+            end
+            begin
+              Thread.current[:result] = Checkpoint.check(
+                product: "vagrant",
+                version: VERSION,
+                signature_file: files[:signature],
+                cache_file: files[:cache]
+              )
+              if !Thread.current[:result].is_a?(Hash)
+                Thread.current[:result] = nil
+              end
+              logger.debug("plugin check complete")
+            rescue => e
+              logger.debug("plugin check failure - #{e}")
+            end
+          end
+        end
+        self
+      end
+
+      # Display any alerts or version update information
+      #
+      # @return [boolean] true if displayed, false if not
+      def display
+        if !defined?(@displayed)
+          if !complete?
+            @logger.debug("waiting for checkpoint to complete...")
+          end
+          # Don't display if information is cached
+          if result && !result["cached"]
+            version_check
+            alerts_check
+          else
+            @logger.debug("no information received from checkpoint")
+          end
+          @displayed = true
+        else
+          false
+        end
+      end
+
+      def alerts_check
+        if result["alerts"] && !result["alerts"].empty?
+          result["alerts"].group_by{|a| a["level"]}.each_pair do |_, alerts|
+            alerts.each do |alert|
+              date = nil
+              begin
+                date = Time.at(alert["date"])
+              rescue
+                date = Time.now
+              end
+              output = I18n.t("vagrant.alert",
+                message: alert["message"],
+                date: date,
+                url: alert["url"]
+              )
+              case alert["level"]
+              when "info"
+                alert_ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
+                alert_ui.info(output)
+              when "warn"
+                alert_ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant-warning")
+                alert_ui.warn(output)
+              when "critical"
+                alert_ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant-alert")
+                alert_ui.error(output)
+              end
+            end
+            env.ui.info("")
+          end
+        else
+          @logger.debug("no alert notifications to display")
+        end
+      end
+
+      def version_check
+        latest_version = Gem::Version.new(result["current_version"])
+        installed_version = Gem::Version.new(VERSION)
+        ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
+        if latest_version > installed_version
+          @logger.info("new version of Vagrant available - #{latest_version}")
+          ui.info(I18n.t("vagrant.version_upgrade_available", latest_version: latest_version, installed_version: installed_version), channel: :error)
+          env.ui.info("", channel: :error)
+        else
+          @logger.debug("vagrant is currently up to date")
+        end
+      end
+
+      # @private
+      # Reset the cached values for platform. This is not considered a public
+      # API and should only be used for testing.
+      def reset!
+        logger = @logger
+        instance_variables.each(&method(:remove_instance_variable))
+        @logger = logger
+        @enabled = false
+      end
+    end
+  end
+end

data/lib/vagrant/util/command_deprecation.rb

@@ -0,0 +1,59 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # Automatically add deprecation notices to commands
+    module CommandDeprecation
+
+      # @return [String] generated name of command
+      def deprecation_command_name
+        name_parts = self.class.name.split("::")
+        [
+          name_parts[1].sub('Command', ''),
+          name_parts[3]
+        ].compact.map(&:downcase).join(" ")
+      end
+
+      def self.included(klass)
+        klass.class_eval do
+          class << self
+            if method_defined?(:synopsis)
+              alias_method :non_deprecated_synopsis, :synopsis
+
+              def synopsis
+                if !non_deprecated_synopsis.to_s.empty?
+                  "#{non_deprecated_synopsis} [DEPRECATED]"
+                else
+                  non_deprecated_synopsis
+                end
+              end
+            end
+          end
+          alias_method :non_deprecated_execute, :execute
+
+          def execute(*args, &block)
+            @env[:ui].warn(I18n.t("vagrant.commands.deprecated",
+              name: deprecation_command_name
+            ) + "\n")
+            non_deprecated_execute(*args, &block)
+          end
+        end
+      end
+
+      # Mark command deprecation complete and fully disable
+      # the command's functionality
+      module Complete
+        def self.included(klass)
+          klass.include(CommandDeprecation)
+          klass.class_eval do
+            def execute(*_)
+              raise Vagrant::Errors::CommandDeprecated,
+                name: deprecation_command_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/counter.rb

@@ -0,0 +1,27 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'thread'
+
+module Vagrant
+  module Util
+    # Atomic counter implementation. This is useful for incrementing
+    # a counter which is guaranteed to only be used once in its class.
+    module Counter
+      def get_and_update_counter(name=nil)
+        name ||= :global
+
+        mutex.synchronize do
+          @__counter ||= Hash.new(1)
+          result = @__counter[name]
+          @__counter[name] += 1
+          result
+        end
+      end
+
+      def mutex
+        @__counter_mutex ||= Mutex.new
+      end
+    end
+  end
+end

data/lib/vagrant/util/credential_scrubber.rb

@@ -0,0 +1,74 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    # Utility class to remove credential information from strings
+    class CredentialScrubber
+      # String used to replace credential information
+      REPLACEMENT_TEXT = "*****".freeze
+
+      # Attempt to remove detected credentials from string
+      #
+      # @param [String] string
+      # @return [String]
+      def self.scrub(string)
+        string = url_scrubber(string)
+      end
+
+      # Detect URLs and remove any embedded credentials
+      #
+      # @param [String] string
+      # @return [String]
+      def self.url_scrubber(string)
+        string.gsub(%r{(ftp|https?)://[^\s]+@[^\s]+}) do |address|
+          uri = URI.parse(address)
+          uri.user = uri.password = REPLACEMENT_TEXT
+          uri.to_s
+        end
+      end
+
+      # Remove sensitive information from string
+      #
+      # @param [String] string
+      # @return [String]
+      def self.desensitize(string)
+        string = string.to_s.dup
+        sensitive_strings.each do |remove|
+          string.gsub!(/(\W|^)#{Regexp.escape(remove)}(\W|$)/, "\\1#{REPLACEMENT_TEXT}\\2")
+        end
+        string
+      end
+
+      # Register a sensitive string to be scrubbed
+      def self.sensitive(string)
+        string = string.to_s.dup
+        if string.length > 0
+          sensitive_strings.push(string).uniq!
+        end
+        nil
+      end
+
+      # Deregister a sensitive string and allow output
+      def self.unsensitive(string)
+        sensitive_strings.delete(string)
+        nil
+      end
+
+      # @return [Array<string>]
+      def self.sensitive_strings
+        if !defined?(@_sensitive_strings)
+          @_sensitive_strings = []
+        end
+        @_sensitive_strings
+      end
+
+      # @private
+      # Reset the cached values for scrubber. This is not considered a public
+      # API and should only be used for testing.
+      def self.reset!
+        instance_variables.each(&method(:remove_instance_variable))
+      end
+    end
+  end
+end

data/lib/vagrant/util/curl_helper.rb

@@ -0,0 +1,104 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    class CurlHelper
+
+      # Hosts that do not require notification on redirect
+      SILENCED_HOSTS = [
+        "vagrantcloud-files-production.s3-accelerate.amazonaws.com".freeze,
+        "vagrantcloud.com".freeze,
+        "vagrantup.com".freeze,
+        "cloud.hashicorp.com".freeze,
+      ].freeze
+
+      def self.capture_output_proc(logger, ui, source=nil)
+        progress_data = ""
+        progress_regexp = /^\r\s*(\d.+?)\r/m
+
+        # Setup the proc that'll receive the real-time data from
+        # the downloader.
+        data_proc = Proc.new do |type, data|
+          # Type will always be "stderr" because that is the only
+          # type of data we're subscribed for notifications.
+
+          # Accumulate progress_data
+          progress_data << data
+
+          redirect_notify = false
+          while true
+            # If the download has been redirected and we are no longer downloading
+            # from the original host, notify the user that the target host has
+            # changed from the source.
+            if progress_data.include?("Location")
+              location = progress_data.scan(/(^|[^\w-])Location: (.+?)$/m).flatten.compact.last.to_s.strip
+              if !location.empty?
+                location_uri = URI.parse(location)
+
+                if !location_uri.host.nil? && !redirect_notify
+                  logger.info("download redirected to #{location}")
+                  source_uri = URI.parse(source)
+                  source_host = source_uri.host.to_s.split(".", 2).last
+                  location_host = location_uri.host.to_s.split(".", 2).last
+                  if location_host != source_host && !SILENCED_HOSTS.include?(location_host) && !SILENCED_HOSTS.include?(location_uri.host.to_s)
+                    ui.rewriting do |_ui|
+                      _ui.clear_line
+                      _ui.detail "Download redirected to host: #{location_uri.host}"
+                    end
+                  end
+                  redirect_notify = true
+                end
+              end
+              progress_data.replace("")
+              break
+            end
+            # If we have a full amount of column data (two "\r") then
+            # we report new progress reports. Otherwise, just keep
+            # accumulating.
+            match = nil
+            check_match = true
+
+            while check_match
+              check_match = progress_regexp.match(progress_data)
+              if check_match
+                data = check_match[1].to_s
+                stop = progress_data.index(data) + data.length
+                progress_data.slice!(0, stop)
+
+                match = check_match
+              end
+            end
+
+            break if !match
+
+            # Ignore the first \r and split by whitespace to grab the columns
+            columns = data.strip.split(/\s+/)
+
+            # COLUMN DATA:
+            #
+            # 0 - % total
+            # 1 - Total size
+            # 2 - % received
+            # 3 - Received size
+            # 4 - % transferred
+            # 5 - Transferred size
+            # 6 - Average download speed
+            # 7 - Average upload speed
+            # 9 - Total time
+            # 9 - Time spent
+            # 10 - Time left
+            # 11 - Current speed
+            output = "Progress: #{columns[0]}% (Rate: #{columns[11]}/s, Estimated time remaining: #{columns[10]})"
+            ui.rewriting do |ui|
+              ui.clear_line
+              ui.detail(output, new_line: false)
+            end
+          end
+        end
+
+        return data_proc
+      end
+    end
+  end
+end

data/lib/vagrant/util/deep_merge.rb

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    module DeepMerge
+      # This was lifted straight from Rails 4.0.2 as a basic Hash
+      # deep merge.
+      def self.deep_merge(myself, other_hash, &block)
+        myself = myself.dup
+        other_hash.each_pair do |k,v|
+          tv = myself[k]
+          if tv.is_a?(Hash) && v.is_a?(Hash)
+            myself[k] = deep_merge(tv, v, &block)
+          else
+            myself[k] = block && tv ? block.call(k, tv, v) : v
+          end
+        end
+        myself
+      end
+    end
+  end
+end

data/lib/vagrant/util/directory.rb

@@ -0,0 +1,22 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'pathname'
+
+module Vagrant
+  module Util
+    class Directory
+      # Check if directory has any new updates
+      #
+      # @param [Pathname, String] Path to directory
+      # @param [Time] time to compare to eg. has any file in dir_path
+      #               changed since this time
+      # @return [Boolean]
+      def self.directory_changed?(dir_path, threshold_time)
+        Dir.glob(Pathname.new(dir_path).join("**", "*")).any? do |path|
+          Pathname.new(path).mtime > threshold_time
+        end
+      end
+    end
+  end
+end