vagrant 1.5.0 → 2.4.4

data/lib/vagrant.rb

@@ -0,0 +1,380 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+# Load the shared helpers first to make the custom
+# require helper available.
+require "vagrant/shared_helpers"
+
+require "log4r"
+
+# Add patches to log4r to support trace level
+require "vagrant/patches/log4r"
+require "vagrant/patches/net-ssh"
+require "vagrant/patches/rubygems"
+require "vagrant/patches/timeout_error"
+
+# Set our log levels and include trace
+require 'log4r/configurator'
+Log4r::Configurator.custom_levels(*(["TRACE"] + Log4r::Log4rConfig::LogLevels))
+
+# Update the default formatter within the log4r library to ensure
+# sensitive values are being properly scrubbed from logger data
+class Log4r::BasicFormatter
+  alias_method :vagrant_format_object, :format_object
+  def format_object(obj)
+    Vagrant::Util::CredentialScrubber.desensitize(vagrant_format_object(obj))
+  end
+end
+
+require "optparse"
+
+module Vagrant
+  # This is a customized OptionParser for Vagrant plugins. It
+  # will automatically add any default CLI options defined
+  # outside of command implementations to the local option
+  # parser instances in use
+  class OptionParser < ::OptionParser
+    def initialize(*_)
+      super
+      Vagrant.default_cli_options.each do |opt_proc|
+        opt_proc.call(self)
+      end
+    end
+  end
+end
+
+# Inject the option parser into the vagrant plugins
+# module so it is automatically used when defining
+# command options
+module VagrantPlugins
+  OptionParser = Vagrant::OptionParser
+end
+
+# Load in our helpers and utilities
+require "rubygems"
+require "vagrant/util"
+require "vagrant/plugin/manager"
+
+# Enable logging if it is requested. We do this before
+# anything else so that we can setup the output before
+# any logging occurs.
+
+# NOTE: We must do this little hack to allow
+# rest-client to write using the `<<` operator.
+# See https://github.com/rest-client/rest-client/issues/34#issuecomment-290858
+# for more information
+class VagrantLogger < Log4r::Logger
+  def << msg
+    debug(msg.strip)
+  end
+end
+
+if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != ""
+  level = Log4r::LNAMES.index(ENV["VAGRANT_LOG"].upcase)
+  if level.nil?
+    level = Log4r::LNAMES.index("FATAL")
+  end
+
+  if !level
+    # We directly write to stderr here because the VagrantError system
+    # is not setup yet.
+    $stderr.puts "Invalid VAGRANT_LOG level is set: #{ENV["VAGRANT_LOG"]}"
+    $stderr.puts ""
+    $stderr.puts "Please use one of the standard log levels: debug, info, warn, or error"
+    exit 1
+  end
+
+  # Set the logging level on all "vagrant" namespaced
+  # logs as long as we have a valid level.
+  if level
+    ["vagrant", "vagrantplugins"].each do |lname|
+      logger = VagrantLogger.new(lname)
+      if ENV["VAGRANT_LOG_FILE"] && ENV["VAGRANT_LOG_FILE"] != ""
+        logger.outputters = Log4r::FileOutputter.new("vagrant", filename: ENV["VAGRANT_LOG_FILE"])
+      else
+        logger.outputters = Log4r::Outputter.stderr
+      end
+      logger.level = level
+    end
+    Log4r::RootLogger.instance.level = level
+
+    base_formatter = Log4r::BasicFormatter.new
+    if ENV["VAGRANT_LOG_TIMESTAMP"]
+      base_formatter = Log4r::PatternFormatter.new(
+        pattern: "%d [%5l] %m",
+        date_pattern: "%F %T"
+      )
+    end
+
+    Log4r::Outputter.stderr.formatter = Vagrant::Util::LoggingFormatter.new(base_formatter)
+  end
+end
+
+require 'json'
+require 'pathname'
+require 'stringio'
+
+require 'childprocess'
+require 'i18n'
+
+# OpenSSL must be loaded here since when it is loaded via `autoload`
+# there are issues with ciphers not being properly loaded.
+require 'openssl'
+
+# Always make the version available
+require 'vagrant/version'
+global_logger = Log4r::Logger.new("vagrant::global")
+Vagrant.global_logger = global_logger
+global_logger.info("Vagrant version: #{Vagrant::VERSION}")
+global_logger.info("Ruby version: #{RUBY_VERSION}")
+global_logger.info("RubyGems version: #{Gem::VERSION}")
+ENV.each do |k, v|
+  next if k.start_with?("VAGRANT_OLD")
+  global_logger.info("#{k}=#{v.inspect}") if k.start_with?("VAGRANT_")
+end
+
+# If the vagrant_ssl library exists, a recent version
+# of openssl is in use and its needed to load all the
+# providers needed
+vagrant_ssl_locations = [
+  File.expand_path("vagrant/vagrant_ssl.so", __dir__),
+  File.expand_path("vagrant/vagrant_ssl.bundle", __dir__)
+]
+if vagrant_ssl_locations.any? { |f| File.exist?(f) }
+  global_logger.debug("vagrant ssl helper found for loading ssl providers")
+  begin
+    require "vagrant/vagrant_ssl"
+    Vagrant.vagrant_ssl_load
+    global_logger.debug("ssl providers successfully loaded")
+  rescue LoadError => err
+    global_logger.warn("failed to load ssl providers, attempting to continue (#{err})")
+  rescue => err
+    global_logger.warn("unexpected failure loading ssl providers, attempting to continue (#{err})")
+  end
+else
+  global_logger.warn("vagrant ssl helper was not found, continuing...")
+end
+
+# We need these components always so instead of an autoload we
+# just require them explicitly here.
+require "vagrant/plugin"
+require "vagrant/registry"
+
+module Vagrant
+  autoload :Action,         'vagrant/action'
+  autoload :Alias,          'vagrant/alias'
+  autoload :BatchAction,    'vagrant/batch_action'
+  autoload :Box,            'vagrant/box'
+  autoload :BoxCollection,  'vagrant/box_collection'
+  autoload :BoxMetadata,    'vagrant/box_metadata'
+  autoload :Bundler,        'vagrant/bundler'
+  autoload :CLI,            'vagrant/cli'
+  autoload :CapabilityHost, 'vagrant/capability_host'
+  autoload :Config,         'vagrant/config'
+  autoload :Environment,    'vagrant/environment'
+  autoload :Errors,         'vagrant/errors'
+  autoload :Guest,          'vagrant/guest'
+  autoload :Host,           'vagrant/host'
+  autoload :Machine,        'vagrant/machine'
+  autoload :MachineIndex,   'vagrant/machine_index'
+  autoload :MachineState,   'vagrant/machine_state'
+  autoload :Plugin,         'vagrant/plugin'
+  autoload :Registry,       'vagrant/registry'
+  autoload :UI,             'vagrant/ui'
+  autoload :Util,           'vagrant/util'
+  autoload :Vagrantfile,    'vagrant/vagrantfile'
+  autoload :VERSION,        'vagrant/version'
+
+  # These are the various plugin versions and their components in
+  # a lazy loaded Hash-like structure.
+  PLUGIN_COMPONENTS = Registry.new.tap do |c|
+    c.register(:"1")                  { Plugin::V1::Plugin }
+    c.register([:"1", :command])      { Plugin::V1::Command }
+    c.register([:"1", :communicator]) { Plugin::V1::Communicator }
+    c.register([:"1", :config])       { Plugin::V1::Config }
+    c.register([:"1", :guest])        { Plugin::V1::Guest }
+    c.register([:"1", :host])         { Plugin::V1::Host }
+    c.register([:"1", :provider])     { Plugin::V1::Provider }
+    c.register([:"1", :provisioner])  { Plugin::V1::Provisioner }
+
+    c.register(:"2")                  { Plugin::V2::Plugin }
+    c.register([:"2", :command])      { Plugin::V2::Command }
+    c.register([:"2", :communicator]) { Plugin::V2::Communicator }
+    c.register([:"2", :config])       { Plugin::V2::Config }
+    c.register([:"2", :guest])        { Plugin::V2::Guest }
+    c.register([:"2", :host])         { Plugin::V2::Host }
+    c.register([:"2", :provider])     { Plugin::V2::Provider }
+    c.register([:"2", :provisioner])  { Plugin::V2::Provisioner }
+    c.register([:"2", :push])         { Plugin::V2::Push }
+    c.register([:"2", :synced_folder]) { Plugin::V2::SyncedFolder }
+
+    c.register(:remote)               { Plugin::Remote::Plugin }
+  end
+
+  # Configure a Vagrant environment. The version specifies the version
+  # of the configuration that is expected by the block. The block, based
+  # on that version, configures the environment.
+  #
+  # Note that the block isn't run immediately. Instead, the configuration
+  # block is stored until later, and is run when an environment is loaded.
+  #
+  # @param [String] version Version of the configuration
+  def self.configure(version, &block)
+    Config.run(version, &block)
+  end
+
+  # This checks if a plugin with the given name is available (installed
+  # and enabled). This can be used from the Vagrantfile to easily branch
+  # based on plugin availability.
+  def self.has_plugin?(name, version=nil)
+    return false unless Vagrant.plugins_enabled?
+
+    if !version
+      # We check the plugin names first because those are cheaper to check
+      return true if plugin("2").manager.registered.any? { |p| p.name == name }
+    end
+
+    # Now check the plugin gem names
+    require "vagrant/plugin/manager"
+    Plugin::Manager.instance.plugin_installed?(name, version)
+  end
+
+  # Returns a superclass to use when creating a plugin for Vagrant.
+  # Given a specific version, this returns a proper superclass to use
+  # to register plugins for that version.
+  #
+  # Optionally, if you give a specific component, then it will return
+  # the proper superclass for that component as well.
+  #
+  # Plugins and plugin components should subclass the classes returned by
+  # this method. This method lets Vagrant core control these superclasses
+  # and change them over time without affecting plugins. For example, if
+  # the V1 superclass happens to be "Vagrant::V1," future versions of
+  # Vagrant may move it to "Vagrant::Plugins::V1" and plugins will not be
+  # affected.
+  #
+  # @param [String] version
+  # @param [String] component
+  # @return [Class]
+  def self.plugin(version, component=nil)
+    # Build up the key and return a result
+    key    = version.to_s.to_sym
+    key    = [key, component.to_s.to_sym] if component
+    result = PLUGIN_COMPONENTS.get(key)
+
+    # If we found our component then we return that
+    return result if result
+
+    # If we didn't find a result, then raise an exception, depending
+    # on if we got a component or not.
+    raise ArgumentError, "Plugin superclass not found for version/component: " +
+      "#{version} #{component}"
+  end
+
+  # @deprecated
+  def self.require_plugin(name)
+    puts "require_plugin is deprecated and has no effect any longer."
+    puts "Use `vagrant plugin` commands to manage plugins. This warning will"
+    puts "be removed in the next version of Vagrant."
+  end
+
+  # This checks if Vagrant is installed in a specific version.
+  #
+  # Example:
+  #
+  #    Vagrant.version?(">= 2.1.0")
+  #
+  def self.version?(*requirements)
+    req = Gem::Requirement.new(*requirements)
+    req.satisfied_by?(Gem::Version.new(VERSION))
+  end
+
+  # This allows a Vagrantfile to specify the version of Vagrant that is
+  # required. You can specify a list of requirements which will all be checked
+  # against the running Vagrant version.
+  #
+  # This should be specified at the _top_ of any Vagrantfile.
+  #
+  # Examples are shown below:
+  #
+  #   require_version(">= 1.3.5")
+  #   require_version(">= 1.3.5", "< 1.4.0")
+  #   require_version("~> 1.3.5")
+  #
+  def self.require_version(*requirements)
+    logger = Log4r::Logger.new("vagrant::root")
+    logger.info("Version requirements from Vagrantfile: #{requirements.inspect}")
+
+    if version?(*requirements)
+      logger.info("  - Version requirements satisfied!")
+      return
+    end
+
+    raise Errors::VagrantVersionBad,
+      requirements: requirements.join(", "),
+      version: VERSION
+  end
+
+  # This allows plugin developers to access the original environment before
+  # Vagrant even ran. This is useful when shelling out, especially to other
+  # Ruby processes.
+  #
+  # @return [Hash]
+  def self.original_env
+    {}.tap do |h|
+      ENV.each do |k,v|
+        if k.start_with?("VAGRANT_OLD_ENV")
+          key = k.sub(/^VAGRANT_OLD_ENV_/, "")
+          if !key.empty?
+            h[key] = v
+          end
+        end
+      end
+    end
+  end
+end
+
+# Default I18n to load the en locale
+I18n.load_path << File.expand_path("templates/locales/en.yml", Vagrant.source_root)
+
+if I18n.config.respond_to?(:enforce_available_locales=)
+  # Make sure only available locales are used. This will be the default in the
+  # future but we need this to silence a deprecation warning from 0.6.9
+  I18n.config.enforce_available_locales = true
+end
+
+if Vagrant.enable_resolv_replace
+  global_logger.info("resolv replacement has been enabled!")
+else
+  global_logger.warn("resolv replacement has not been enabled!")
+end
+
+# A lambda that knows how to load plugins from a single directory.
+plugin_load_proc = lambda do |directory|
+  # We only care about directories
+  next false if !directory.directory?
+
+  # If there is a plugin file in the top-level directory, then load
+  # that up.
+  plugin_file = directory.join("plugin.rb")
+  if plugin_file.file?
+    global_logger.debug("Loading core plugin: #{plugin_file}")
+    load(plugin_file)
+    next true
+  end
+end
+
+# Go through the `plugins` directory and attempt to load any plugins. The
+# plugins are allowed to be in a directory in `plugins` or at most one
+# directory deep within the plugins directory. So a plugin can be at
+# `plugins/foo` or also at `plugins/foo/bar`, but no deeper.
+Vagrant.source_root.join("plugins").children(true).each do |directory|
+  # Ignore non-directories
+  next if !directory.directory?
+
+  # Load from this directory, and exit if we successfully loaded a plugin
+  next if plugin_load_proc.call(directory)
+
+  # Otherwise, attempt to load from sub-directories
+  directory.children(true).each(&plugin_load_proc)
+end

data/plugins/README.md

@@ -0,0 +1,11 @@
+# Vagrant Core Plugins
+
+These are plugins that ship with Vagrant. Vagrant core uses its own
+plugin system to power a lot of the core pieces that ship with Vagrant.
+Each plugin will have its own README which explains its specific role.
+
+## Generate proto
+
+```
+grpc_tools_ruby_protoc -I . --ruby_out=gen/plugin --grpc_out=gen/plugin ./plugin_server.proto
+```

data/plugins/commands/autocomplete/command/install.rb

@@ -0,0 +1,52 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+require 'vagrant/util/install_cli_autocomplete'
+
+module VagrantPlugins
+  module CommandAutocomplete
+    module Command
+      class Install < Vagrant.plugin("2", :command)
+        def execute
+          options = {
+            shells: []
+          }
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant autocomplete install [-h] [shell name]"
+            o.separator ""
+            o.separator "Available shells: #{Vagrant::Util::InstallCLIAutocomplete::SUPPORTED_SHELLS.keys.join(' ')}"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-b", "--bash", "Install bash autocomplete") do |c|
+              options[:shells].append("bash")
+            end
+
+            o.on("-z", "--zsh", "Install zsh autocomplete") do |c|
+              options[:shells].append("zsh")
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length > 0
+
+          written_paths = Vagrant::Util::InstallCLIAutocomplete.install(options[:shells])
+          if written_paths && written_paths.length > 0
+            @env.ui.info(I18n.t("vagrant.autocomplete.installed", paths: written_paths.join("\n- ")))
+          else
+            @env.ui.info(I18n.t("vagrant.autocomplete.not_installed"))
+          end
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/autocomplete/command/root.rb

@@ -0,0 +1,69 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "optparse"
+require 'vagrant/util/install_cli_autocomplete'
+
+module VagrantPlugins
+  module CommandAutocomplete
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "manages autocomplete installation on host"
+        end
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:install) do
+            require File.expand_path("../install", __FILE__)
+            Install
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the box commands.
+            return help
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        def help
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant autocomplete <subcommand>"
+            if !Vagrant.server_mode?
+              opts.separator ""
+              opts.separator "Available subcommands:"
+
+              # Add the available subcommands as separators in order to print them
+              # out as well.
+              keys = []
+              keys = @subcommands.keys.map(&:to_s)
+
+              keys.sort.each do |key|
+                opts.separator "     #{key}"
+              end
+            end
+
+            opts.separator ""
+            opts.separator "For help on any individual subcommand run `vagrant autocomplete <subcommand> -h`"
+          end
+
+          @env.ui.info(opts.help, prefix: false)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/autocomplete/plugin.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+
+module VagrantPlugins
+  module CommandAutocomplete
+    class Plugin < Vagrant.plugin("2")
+      name "autocomplete command"
+      description <<-DESC
+      The `autocomplete` manipulates Vagrant the autocomplete feature.
+      DESC
+
+      command("autocomplete") do
+        require File.expand_path("../command/root", __FILE__)
+        Command::Root
+      end
+    end
+  end
+end

data/plugins/commands/box/command/add.rb

@@ -0,0 +1,111 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+require_relative 'download_mixins'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Add < Vagrant.plugin("2", :command)
+        include DownloadMixins
+
+        def execute
+          options = {
+            architecture: :auto,
+          }
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box add [options] <name, url, or path>"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-c", "--clean", "Clean any temporary download files") do |c|
+              options[:clean] = c
+            end
+
+            o.on("-f", "--force", "Overwrite an existing box if it exists") do |f|
+              options[:force] = f
+            end
+
+            build_download_options(o, options)
+
+            o.on("--location-trusted", "Trust 'Location' header from HTTP redirects and use the same credentials for subsequent urls as for the initial one") do |l|
+                options[:location_trusted] = l
+            end
+
+            o.on("-a", "--architecture ARCH", String, "Architecture the box should satisfy") do |a|
+              options[:architecture] = a
+            end
+
+            o.on("--provider PROVIDER", String, "Provider the box should satisfy") do |p|
+              options[:provider] = p
+            end
+
+            o.on("--box-version VERSION", String, "Constrain version of the added box") do |v|
+              options[:version] = v
+            end
+
+            o.separator ""
+            o.separator "The box descriptor can be the name of a box on HashiCorp's Vagrant Cloud,"
+            o.separator "or a URL, or a local .box file, or a local .json file containing"
+            o.separator "the catalog metadata."
+            o.separator ""
+            o.separator "The options below only apply if you're adding a box file directly,"
+            o.separator "and not using a Vagrant server or a box structured like 'user/box':"
+            o.separator ""
+
+            o.on("--checksum CHECKSUM", String, "Checksum for the box") do |c|
+              options[:checksum] = c
+            end
+
+            o.on("--checksum-type TYPE", String, "Checksum type (md5, sha1, sha256)") do |c|
+              options[:checksum_type] = c.to_sym
+            end
+
+            o.on("--name BOX", String, "Name of the box") do |n|
+              options[:name] = n
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          if argv.empty? || argv.length > 2
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          url = argv[0]
+          if argv.length == 2
+            options[:name] = argv[0]
+            url = argv[1]
+          end
+
+          @env.action_runner.run(Vagrant::Action.action_box_add, {
+            box_url: url,
+            box_name: options[:name],
+            box_provider: options[:provider],
+            box_architecture: options[:architecture],
+            box_version: options[:version],
+            box_checksum_type: options[:checksum_type],
+            box_checksum: options[:checksum],
+            box_clean: options[:clean],
+            box_force: options[:force],
+            box_download_ca_cert: options[:ca_cert],
+            box_download_ca_path: options[:ca_path],
+            box_download_client_cert: options[:client_cert],
+            box_download_insecure: options[:insecure],
+            box_download_location_trusted: options[:location_trusted],
+            ui: Vagrant::UI::Prefixed.new(@env.ui, "box"),
+          })
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/download_mixins.rb

@@ -0,0 +1,32 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommandBox
+    module DownloadMixins
+      # This adds common download command line flags to the given
+      # OptionParser, storing the result in the `options` dictionary.
+      #
+      # @param [OptionParser] parser
+      # @param [Hash] options
+      def build_download_options(parser, options)
+        # Add the options
+        parser.on("--insecure", "Do not validate SSL certificates") do |i|
+          options[:insecure] = i
+        end
+
+        parser.on("--cacert FILE", String, "CA certificate for SSL download") do |c|
+          options[:ca_cert] = c
+        end
+
+        parser.on("--capath DIR", String, "CA certificate directory for SSL download") do |c|
+          options[:ca_path] = c
+        end
+
+        parser.on("--cert FILE", String, "A client SSL cert, if needed") do |c|
+          options[:client_cert] = c
+        end
+      end
+    end
+  end
+end