vagrant 1.5.0 → 2.4.5

data/lib/vagrant/shared_helpers.rb

@@ -0,0 +1,238 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "pathname"
+require "tempfile"
+require "thread"
+
+module Vagrant
+  @@global_lock = Mutex.new
+
+  # This is the default endpoint of the Vagrant Cloud in
+  # use. API calls will be made to this for various functions
+  # of Vagrant that may require remote access.
+  #
+  # @return [String]
+  DEFAULT_SERVER_URL = "https://vagrantcloud.com".freeze
+
+  # Max number of seconds to wait for joining an active thread.
+  #
+  # @return [Integer]
+  # @note This is not the maximum time for a thread to complete.
+  THREAD_MAX_JOIN_TIMEOUT = 60
+
+  # List of required external tools that are expected to be
+  # present when running outside of the installers
+  REQUIRED_EXTERNAL_TOOLS = ["bsdtar", "curl", "ssh"].map(&:freeze).freeze
+
+  # This holds a global lock for the duration of the block. This should
+  # be invoked around anything that is modifying process state (such as
+  # environmental variables).
+  def self.global_lock
+    @@global_lock.synchronize do
+      return yield
+    end
+  end
+
+  # This returns a true/false showing whether we're running from the
+  # environment setup by the Vagrant installers.
+  #
+  # @return [Boolean]
+  def self.in_installer?
+    !!ENV["VAGRANT_INSTALLER_ENV"]
+  end
+
+  # This returns a true/false if we are running within a bundler environment
+  #
+  # @return [Boolean]
+  def self.in_bundler?
+    !!ENV["BUNDLE_GEMFILE"] &&
+      !defined?(::Bundler).nil?
+  end
+
+  # Returns the path to the embedded directory of the Vagrant installer,
+  # if there is one (if we're running in an installer).
+  #
+  # @return [String]
+  def self.installer_embedded_dir
+    return nil if !Vagrant.in_installer?
+    ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"]
+  end
+
+  # Should the plugin system be initialized
+  #
+  # @return [Boolean]
+  def self.plugins_init?
+    !ENV['VAGRANT_DISABLE_PLUGIN_INIT']
+  end
+
+  # This returns whether or not 3rd party plugins should and can be loaded.
+  #
+  # @return [Boolean]
+  def self.plugins_enabled?
+    !ENV["VAGRANT_NO_PLUGINS"]
+  end
+
+  # Whether or not super quiet mode is enabled. This is ill-advised.
+  #
+  # @return [Boolean]
+  def self.very_quiet?
+    !!ENV["VAGRANT_I_KNOW_WHAT_IM_DOING_PLEASE_BE_QUIET"]
+  end
+
+  # The current log level for Vagrant
+  #
+  # @return [String]
+  def self.log_level
+    ENV.fetch("VAGRANT_LOG", "fatal").downcase
+  end
+
+  # Returns the URL prefix to the server.
+  #
+  # @return [String]
+  def self.server_url(config_server_url=nil)
+    result = ENV["VAGRANT_SERVER_URL"]
+    result = config_server_url if result == "" or result == nil
+    result || DEFAULT_SERVER_URL
+  end
+
+  # The source root is the path to the root directory of the Vagrant source.
+  #
+  # @return [Pathname]
+  def self.source_root
+    @source_root ||= Pathname.new(File.expand_path('../../../', __FILE__))
+  end
+
+  # This returns the path to the ~/.vagrant.d folder where Vagrant's
+  # per-user state is stored.
+  #
+  # @return [Pathname]
+  def self.user_data_path
+    # Use user specified env var if available
+    path = ENV["VAGRANT_HOME"]
+
+    # On Windows, we default to the USERPROFILE directory if it
+    # is available. This is more compatible with Cygwin and sharing
+    # the home directory across shells.
+    if !path && ENV["USERPROFILE"]
+      path = "#{ENV["USERPROFILE"]}/.vagrant.d"
+    end
+
+    # Fallback to the default
+    path ||= "~/.vagrant.d"
+
+    Pathname.new(path).expand_path
+  end
+
+  # This returns true/false if the running version of Vagrant is
+  # a pre-release version (development)
+  #
+  # @return [Boolean]
+  def self.prerelease?
+    Gem::Version.new(Vagrant::VERSION).prerelease?
+  end
+
+  # This returns true/false if the Vagrant should allow prerelease
+  # versions when resolving plugin dependency constraints
+  #
+  # @return [Boolean]
+  def self.allow_prerelease_dependencies?
+    !!ENV["VAGRANT_ALLOW_PRERELEASE"]
+  end
+
+  # This allows control over dependency resolution when installing
+  # plugins into vagrant. When true, dependency libraries that Vagrant
+  # core relies upon will be hard constraints.
+  #
+  # @return [Boolean]
+  def self.strict_dependency_enforcement
+    if ENV["VAGRANT_DISABLE_STRICT_DEPENDENCY_ENFORCEMENT"]
+      false
+    else
+      true
+    end
+  end
+
+  # Automatically install locally defined plugins instead of
+  # waiting for user confirmation.
+  #
+  # @return [Boolean]
+  def self.auto_install_local_plugins?
+    if ENV["VAGRANT_INSTALL_LOCAL_PLUGINS"]
+      true
+    else
+      false
+    end
+  end
+
+  # Use Ruby Resolv in place of libc
+  #
+  # @return [boolean] enabled or not
+  def self.enable_resolv_replace
+    if ENV["VAGRANT_ENABLE_RESOLV_REPLACE"]
+      if !ENV["VAGRANT_DISABLE_RESOLV_REPLACE"]
+        begin
+          require "resolv-replace"
+          true
+        rescue
+          false
+        end
+      else
+        false
+      end
+    end
+  end
+
+  # Set the global logger
+  #
+  # @param log Logger
+  # @return [Logger]
+  def self.global_logger=(log)
+    @_global_logger = log
+  end
+
+  # Get the global logger instance
+  #
+  # @return [Logger]
+  def self.global_logger
+    if @_global_logger.nil?
+      require "log4r"
+      @_global_logger = Log4r::Logger.new("vagrant::global")
+    end
+    @_global_logger
+  end
+
+  # Add a new block of default CLI options which
+  # should be automatically added to all commands
+  #
+  # @param [Proc] block Proc instance containing OptParser configuration
+  # @return [nil]
+  def self.add_default_cli_options(block)
+    if !block.is_a?(Proc)
+      raise TypeError,
+        "Expecting type `Proc` but received `#{block.class}`"
+    end
+    if block.arity != 1 && block.arity != -1
+      raise ArgumentError,
+        "Proc must accept OptionParser argument"
+    end
+    @_default_cli_options = [] if !@_default_cli_options
+    @_default_cli_options << block
+    nil
+  end
+
+  # Array of default CLI options to automatically
+  # add to commands.
+  #
+  # @return [Array<Proc>] Default optparse options
+  def self.default_cli_options
+    @_default_cli_options = [] if !@_default_cli_options
+    @_default_cli_options.dup
+  end
+
+  def self.detect_missing_tools
+    REQUIRED_EXTERNAL_TOOLS.find_all do |tool|
+      !Vagrant::Util::Which.which(tool)
+    end
+  end
+end

data/lib/vagrant/ui.rb

@@ -0,0 +1,449 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "delegate"
+require "io/console"
+require "thread"
+require "log4r"
+require "vagrant/util/platform"
+require "vagrant/util/safe_puts"
+
+module Vagrant
+  module UI
+    # Vagrant UIs handle communication with the outside world (typically
+    # through a shell). They must respond to the following methods:
+    #
+    # * `info`
+    # * `warn`
+    # * `error`
+    # * `success`
+    class Interface
+      # Opts can be used to set some options. These options are implementation
+      # specific. See the implementation for more docs.
+      attr_accessor :opts
+
+      # @return [IO] UI input. Defaults to `$stdin`.
+      attr_accessor :stdin
+
+      # @return [IO] UI output. Defaults to `$stdout`.
+      attr_accessor :stdout
+
+      # @return [IO] UI error output. Defaults to `$stderr`.
+      attr_accessor :stderr
+
+      def initialize
+        @logger   = Log4r::Logger.new("vagrant::ui::interface")
+        @opts     = {}
+
+        @stdin  = $stdin
+        @stdout = $stdout
+        @stderr = $stderr
+      end
+
+      def initialize_copy(original)
+        super
+        @opts = original.opts.dup
+      end
+
+      [:ask, :detail, :warn, :error, :info, :output, :success].each do |method|
+        define_method(method) do |message, **opts|
+          # Log normal console messages
+          begin
+            @logger.info { "#{method}: #{message}" }
+          rescue ThreadError
+            # We're being called in a trap-context. Wrap in a thread.
+            Thread.new do
+              @logger.info { "#{method}: #{message}" }
+            end.join(THREAD_MAX_JOIN_TIMEOUT)
+          end
+        end
+      end
+
+      [:clear_line, :report_progress].each do |method|
+        # By default do nothing, these aren't logged
+        define_method(method) { |*args| }
+      end
+
+      # @return [false]
+      def color?
+        return false
+      end
+
+      # For machine-readable output.
+      #
+      # @param [String] type The type of the data
+      # @param [Array] data The data associated with the type
+      def machine(type, *data)
+        @logger.info("Machine: #{type} #{data.inspect}")
+      end
+
+      # Yields self (UI)
+      # Provides a way for selectively displaying or not displaying
+      # updating content like download progress.
+      def rewriting
+        yield self
+      end
+
+      def to_proto
+        raise NotImplementedError,
+          "Vagrant::UI::Interface#to_proto"
+      end
+    end
+
+    # This is a UI implementation that does nothing.
+    class Silent < Interface
+      def ask(*args, **opts)
+        super
+
+        # Silent can't do this, obviously.
+        raise Errors::UIExpectsTTY
+      end
+    end
+
+    class MachineReadable < Interface
+      include Util::SafePuts
+
+      def initialize
+        super
+
+        @lock = Mutex.new
+      end
+
+      def ask(*args, **opts)
+        super
+
+        # Machine-readable can't ask for input
+        raise Errors::UIExpectsTTY
+      end
+
+      [:detail, :warn, :error, :info, :output, :success].each do |method|
+        define_method(method) do |message, **opts|
+          machine("ui", method.to_s, message, **opts)
+        end
+      end
+
+      def machine(type, *data)
+        opts = {}
+        opts = data.pop if data.last.kind_of?(Hash)
+
+        target = opts[:target] || ""
+
+        # Prepare the data by replacing characters that aren't outputted
+        data.each_index do |i|
+          data[i] = data[i].to_s.dup
+          data[i].gsub!(",", "%!(VAGRANT_COMMA)")
+          data[i].gsub!("\n", "\\n")
+          data[i].gsub!("\r", "\\r")
+        end
+
+        # Avoid locks in a trap context introduced from Ruby 2.0
+        Thread.new do
+          @lock.synchronize do
+            safe_puts("#{Time.now.utc.to_i},#{target},#{type},#{data.join(",")}")
+          end
+        end.join(THREAD_MAX_JOIN_TIMEOUT)
+      end
+    end
+
+    # This is a UI implementation that outputs the text as is. It
+    # doesn't add any color.
+    class Basic < Interface
+      include Util::SafePuts
+
+      def initialize
+        super
+
+        @lock = Mutex.new
+      end
+
+      # Use some light meta-programming to create the various methods to
+      # output text to the UI. These all delegate the real functionality
+      # to `say`.
+      [:detail, :info, :warn, :error, :output, :success].each do |method|
+        class_eval <<-CODE
+          def #{method}(message, **opts)
+            super(message)
+            say(#{method.inspect}, message, **opts)
+          end
+        CODE
+      end
+
+      def ask(message, **opts)
+        super(message)
+
+        # We can't ask questions when the output isn't a TTY.
+        raise Errors::UIExpectsTTY if !@stdin.tty? && !Vagrant::Util::Platform.windows?
+
+        # Setup the options so that the new line is suppressed
+        opts ||= {}
+        opts[:echo]     = true  if !opts.key?(:echo)
+        opts[:new_line] = false if !opts.key?(:new_line)
+        opts[:prefix]   = false if !opts.key?(:prefix)
+
+        # Output the data
+        say(:info, message, opts)
+
+        input = nil
+        if opts[:echo] || !@stdin.respond_to?(:noecho)
+          input = @stdin.gets
+        else
+          begin
+            input = @stdin.noecho(&:gets)
+
+            # Output a newline because without echo, the newline isn't
+            # echoed either.
+            say(:info, "\n", opts)
+          rescue Errno::EBADF
+            # This means that stdin doesn't support echoless input.
+            say(:info, "\n#{I18n.t("vagrant.stdin_cant_hide_input")}\n ", opts)
+
+            # Ask again, with echo enabled
+            input = ask(message, **opts.merge(echo: true))
+          end
+        end
+
+        # Get the results and chomp off the newline. We do a logical OR
+        # here because `gets` can return a nil, for example in the case
+        # that ctrl-D is pressed on the input.
+        (input || "").chomp
+      end
+
+      # This is used to output progress reports to the UI.
+      # Send this method progress/total and it will output it
+      # to the UI. Send `clear_line` to clear the line to show
+      # a continuous progress meter.
+      def report_progress(progress, total, show_parts=true)
+        if total && total > 0
+          percent = (progress.to_f / total.to_f) * 100
+          line    = "Progress: #{percent.to_i}%"
+          line   << " (#{progress} / #{total})" if show_parts
+        else
+          line    = "Progress: #{progress}"
+        end
+
+        info(line, new_line: false)
+      end
+
+      def clear_line
+        # See: https://en.wikipedia.org/wiki/ANSI_escape_code
+        reset = "\r\033[K"
+
+        info(reset, new_line: false)
+      end
+
+      # This method handles actually outputting a message of a given type
+      # to the console.
+      def say(type, message, opts={})
+        defaults = { new_line: true, prefix: true }
+        opts     = defaults.merge(@opts).merge(opts)
+
+        # Don't output if we're hiding details
+        return if type == :detail && opts[:hide_detail]
+
+        # Determine whether we're expecting to output our
+        # own new line or not.
+        printer = opts[:new_line] ? :puts : :print
+
+        # Determine the proper IO channel to send this message
+        # to based on the type of the message
+        channel = type == :error || opts[:channel] == :error ? @stderr : @stdout
+
+        # Output! We wrap this in a lock so that it safely outputs only
+        # one line at a time. We wrap this in a thread because as of Ruby 2.0
+        # we can't acquire locks in a trap context (ctrl-c), so we have to
+        # do this.
+        Thread.new do
+          @lock.synchronize do
+            safe_puts(format_message(type, message, **opts),
+                      io: channel, printer: printer)
+          end
+        end.join(THREAD_MAX_JOIN_TIMEOUT)
+      end
+
+      def format_message(type, message, **opts)
+        Util::CredentialScrubber.desensitize(message)
+      end
+    end
+
+    class NonInteractive < Basic
+      def initialize
+        super
+      end
+
+      def rewriting
+        # no-op
+      end
+
+      def report_progress(progress, total, show_parts=true)
+        # no-op
+      end
+
+      def clear_line
+        @logger.warn("Using `clear line` in a non interactive ui")
+        say(:info, "\n", opts)
+      end
+
+      def ask(*args, **opts)
+        # Non interactive can't ask for input
+        raise Errors::UIExpectsTTY
+      end
+    end
+
+    # Prefixed wraps an existing UI and adds a prefix to it.
+    class Prefixed < Interface
+      # The prefix for `output` messages.
+      OUTPUT_PREFIX = "==> "
+
+      def initialize(ui, prefix)
+        super()
+
+        @prefix = prefix
+        @ui     = ui
+      end
+
+      def to_proto
+        @ui.to_proto
+      end
+
+      def client
+        @ui.client
+      end
+
+      def initialize_copy(original)
+        super
+        @ui = original.instance_variable_get(:@ui).dup
+      end
+
+      # Use some light meta-programming to create the various methods to
+      # output text to the UI. These all delegate the real functionality
+      # to `say`.
+      [:ask, :detail, :info, :warn, :error, :output, :success].each do |method|
+        class_eval <<-CODE
+          def #{method}(message, **opts)
+            super(message)
+            if !@ui.opts.key?(:bold) && !opts.key?(:bold)
+              opts[:bold] = #{method.inspect} != :detail && \
+                #{method.inspect} != :ask
+            end
+            if !opts.key?(:target)
+              opts[:target] = @prefix
+            end
+            @ui.#{method}(format_message(#{method.inspect}, message, **opts), **opts)
+          end
+        CODE
+      end
+
+      [:clear_line, :report_progress].each do |method|
+        # By default do nothing, these aren't formatted
+        define_method(method) do |*args|
+          @ui.send(method, *args)
+        end
+      end
+
+      # For machine-readable output, set the prefix in the
+      # options hash and continue it on.
+      def machine(type, *data)
+        opts = {}
+        opts = data.pop if data.last.is_a?(Hash)
+        opts[:target] = @prefix
+        data << opts
+        @ui.machine(type, *data)
+      end
+
+      # Return the parent's opts.
+      #
+      # @return [Hash]
+      def opts
+        @ui.opts
+      end
+
+      def format_message(type, message, **opts)
+        opts = self.opts.merge(opts)
+
+        prefix = ""
+        if !opts.key?(:prefix) || opts[:prefix]
+          prefix = OUTPUT_PREFIX
+          prefix = " " * OUTPUT_PREFIX.length if \
+            type == :detail || type == :ask || opts[:prefix_spaces]
+        end
+
+        message = Util::CredentialScrubber.desensitize(message)
+
+        # Fast-path if there is no prefix
+        return message if prefix.empty?
+
+        target = @prefix
+        target = opts[:target] if opts.key?(:target)
+        target = "#{target}:" if target != ""
+
+        lines = [message]
+        if message != ""
+          lines = [].tap do |l|
+            message.scan(/(.*?)(\n|$)/).each do |m|
+              l << m.first if m.first != "" || (m.first == "" && m.last == "\n")
+            end
+          end
+          lines << "" if message.end_with?("\n")
+        end
+
+        # Otherwise, make sure to prefix every line properly
+        lines.map do |line|
+          "#{prefix}#{target} #{line}"
+        end.join("\n")
+      end
+
+      def rewriting
+        @ui.rewriting do |ui|
+          yield ui
+        end
+      end
+
+    end
+
+    # This is a UI implementation that outputs color for various types
+    # of messages. This should only be used with a TTY that supports color,
+    # but is up to the user of the class to verify this is the case.
+    class Colored < Basic
+      # Terminal colors
+      COLORS = {
+        red:     31,
+        green:   32,
+        yellow:  33,
+        blue:    34,
+        magenta: 35,
+        cyan:    36,
+        white:   37,
+      }
+
+      # @return [true]
+      def color?
+        return true
+      end
+
+      # This is called by `say` to format the message for output.
+      def format_message(type, message, **opts)
+        # Get the format of the message before adding color.
+        message = super
+
+        opts = @opts.merge(opts)
+
+        # Special case some colors for certain message types
+        opts[:color] = :red if type == :error
+        opts[:color] = :green if type == :success
+        opts[:color] = :yellow if type == :warn
+
+        # If it is a detail, it is not bold. Every other message type
+        # is bolded.
+        bold  = !!opts[:bold]
+        colorseq = "#{bold ? 1 : 0 }"
+        if opts[:color] && opts[:color] != :default
+          color = COLORS[opts[:color]]
+          colorseq += ";#{color}"
+        end
+
+        # Color the message and make sure to reset the color at the end
+        "\033[#{colorseq}m#{message}\033[0m"
+      end
+    end
+  end
+end

data/lib/vagrant/util/ansi_escape_code_remover.rb

@@ -0,0 +1,37 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    module ANSIEscapeCodeRemover
+      # Removes ANSI escape code sequences from the text and returns
+      # it.
+      #
+      # This removes all the ANSI escape codes listed here along with
+      # the escape codes for VT100 terminals:
+      #
+      # http://ascii-table.com/ansi-escape-sequences.php
+      def remove_ansi_escape_codes(text)
+        # An array of regular expressions which match various kinds
+        # of escape sequences. I can't think of a better single regular
+        # expression or any faster way to do this.
+        matchers = [/\e\[\d*[ABCD]/,       # Matches things like \e[4D
+                    /\e\[(\d*;)?\d*[HF]/,  # Matches \e[1;2H or \e[H
+                    /\e\[(s|u|2J|K)/,      # Matches \e[s, \e[2J, etc.
+                    /\e\[=\d*[hl]/,        # Matches \e[=24h
+                    /\e\[\?[1-9][hl]/,     # Matches \e[?2h
+                    /\e\[20[hl]/,          # Matches \e[20l]
+                    /\e[DME78H]/,          # Matches \eD, \eH, etc.
+                    /\e\[[0-3]?[JK]/,      # Matches \e[0J, \e[K, etc.
+                    ]
+
+        # Take each matcher and replace it with emptiness.
+        matchers.each do |matcher|
+          text.gsub!(matcher, "")
+        end
+
+        text
+      end
+    end
+  end
+end