vagrant 1.0.7 → 2.4.4

data/lib/vagrant.rb

@@ -1,27 +1,79 @@
-require 'log4r'
+# 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.
-if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != ""
-  # Require Log4r and define the levels we'll be using
-  require 'log4r/config'
-  Log4r.define_levels(*Log4r::Log4rConfig::LogLevels)
 
-  level = nil
-  begin
-    level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
-  rescue NameError
-    # This means that the logging constant wasn't found,
-    # which is fine. We just keep `level` as `nil`. But
-    # we tell the user.
-    level = nil
+# 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
 
-  # Some constants, such as "true" resolve to booleans, so the
-  # above error checking doesn't catch it. This will check to make
-  # sure that the log level is an integer, as Log4r requires.
-  level = nil if !level.is_a?(Integer)
+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
@@ -35,16 +87,34 @@ if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != ""
   # Set the logging level on all "vagrant" namespaced
   # logs as long as we have a valid level.
   if level
-    logger = Log4r::Logger.new("vagrant")
-    logger.outputters = Log4r::Outputter.stderr
-    logger.level = level
-    logger = nil
+    ["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 'json'
 require 'i18n'
 
 # OpenSSL must be loaded here since when it is loaded via `autoload`
@@ -53,145 +123,258 @@ require 'openssl'
 
 # Always make the version available
 require 'vagrant/version'
-Log4r::Logger.new("vagrant::global").info("Vagrant version: #{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 :Box,           'vagrant/box'
-  autoload :BoxCollection, 'vagrant/box_collection'
-  autoload :CLI,           'vagrant/cli'
-  autoload :Command,       'vagrant/command'
-  autoload :Communication, 'vagrant/communication'
-  autoload :Config,        'vagrant/config'
-  autoload :DataStore,     'vagrant/data_store'
-  autoload :Downloaders,   'vagrant/downloaders'
-  autoload :Driver,        'vagrant/driver'
-  autoload :Environment,   'vagrant/environment'
-  autoload :Errors,        'vagrant/errors'
-  autoload :Guest,         'vagrant/guest'
-  autoload :Hosts,         'vagrant/hosts'
-  autoload :Plugin,        'vagrant/plugin'
-  autoload :Provisioners,  'vagrant/provisioners'
-  autoload :Registry,      'vagrant/registry'
-  autoload :SSH,           'vagrant/ssh'
-  autoload :TestHelpers,   'vagrant/test_helpers'
-  autoload :UI,            'vagrant/ui'
-  autoload :Util,          'vagrant/util'
-  autoload :VM,            'vagrant/vm'
-
-  # Returns a `Vagrant::Registry` object that contains all the built-in
-  # middleware stacks.
-  def self.actions
-    @actions ||= Vagrant::Action::Builtin.new
-  end
-
-  # The source root is the path to the root directory of
-  # the Vagrant gem.
-  def self.source_root
-    @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
-  end
-
-  # Global registry of commands that are available via the CLI.
+  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.
   #
-  # This registry is used to look up the sub-commands that are available
-  # to Vagrant.
-  def self.commands
-    @commands ||= Registry.new
+  # @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
 
-  # Global registry of config keys that are available.
+  # 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.
   #
-  # This registry is used to look up the keys for `config` objects.
-  # For example, `config.vagrant` looks up the `:vagrant` config key
-  # for the configuration class to use.
-  def self.config_keys
-    @config_keys ||= Registry.new
+  # 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
 
-  # Global registry of available host classes and shortcut symbols
-  # associated with them.
+  # @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")
   #
-  # This registry is used to look up the shorcuts for `config.vagrant.host`,
-  # or to query all hosts for automatically detecting the host system.
-  # The registry is global to all of Vagrant.
-  def self.hosts
-    @hosts ||= Registry.new
+  def self.version?(*requirements)
+    req = Gem::Requirement.new(*requirements)
+    req.satisfied_by?(Gem::Version.new(VERSION))
   end
 
-  # Global registry of available guest classes and shortcut symbols
-  # associated with them.
+  # 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 registry is used to look up the shortcuts for `config.vm.guest`.
-  def self.guests
-    @guests ||= Registry.new
+  # 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
 
-  # Global registry of provisioners.
+  # This allows plugin developers to access the original environment before
+  # Vagrant even ran. This is useful when shelling out, especially to other
+  # Ruby processes.
   #
-  # This registry is used to look up the provisioners provided for
-  # `config.vm.provision`.
-  def self.provisioners
-    @provisioners ||= Registry.new
+  # @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
+# Default I18n to load the en locale
 I18n.load_path << File.expand_path("templates/locales/en.yml", Vagrant.source_root)
 
-# Register the built-in commands
-Vagrant.commands.register(:box)          { Vagrant::Command::Box }
-Vagrant.commands.register(:destroy)      { Vagrant::Command::Destroy }
-Vagrant.commands.register(:gem)          { Vagrant::Command::Gem }
-Vagrant.commands.register(:halt)         { Vagrant::Command::Halt }
-Vagrant.commands.register(:init)         { Vagrant::Command::Init }
-Vagrant.commands.register(:package)      { Vagrant::Command::Package }
-Vagrant.commands.register(:provision)    { Vagrant::Command::Provision }
-Vagrant.commands.register(:reload)       { Vagrant::Command::Reload }
-Vagrant.commands.register(:resume)       { Vagrant::Command::Resume }
-Vagrant.commands.register(:ssh)          { Vagrant::Command::SSH }
-Vagrant.commands.register(:"ssh-config") { Vagrant::Command::SSHConfig }
-Vagrant.commands.register(:status)       { Vagrant::Command::Status }
-Vagrant.commands.register(:suspend)      { Vagrant::Command::Suspend }
-Vagrant.commands.register(:up)           { Vagrant::Command::Up }
-
-# Register the built-in config keys
-Vagrant.config_keys.register(:vagrant) { Vagrant::Config::VagrantConfig }
-Vagrant.config_keys.register(:ssh)     { Vagrant::Config::SSHConfig }
-Vagrant.config_keys.register(:nfs)     { Vagrant::Config::NFSConfig }
-Vagrant.config_keys.register(:vm)      { Vagrant::Config::VMConfig }
-Vagrant.config_keys.register(:package) { Vagrant::Config::PackageConfig }
-
-# Register the built-in hosts
-Vagrant.hosts.register(:arch)    { Vagrant::Hosts::Arch }
-Vagrant.hosts.register(:bsd)     { Vagrant::Hosts::BSD }
-Vagrant.hosts.register(:fedora)  { Vagrant::Hosts::Fedora }
-Vagrant.hosts.register(:opensuse)  { Vagrant::Hosts::OpenSUSE }
-Vagrant.hosts.register(:freebsd) { Vagrant::Hosts::FreeBSD }
-Vagrant.hosts.register(:gentoo)  { Vagrant::Hosts::Gentoo }
-Vagrant.hosts.register(:linux)   { Vagrant::Hosts::Linux }
-Vagrant.hosts.register(:windows) { Vagrant::Hosts::Windows }
-
-# Register the built-in guests
-Vagrant.guests.register(:arch)    { Vagrant::Guest::Arch }
-Vagrant.guests.register(:debian)  { Vagrant::Guest::Debian }
-Vagrant.guests.register(:fedora)  { Vagrant::Guest::Fedora }
-Vagrant.guests.register(:freebsd) { Vagrant::Guest::FreeBSD }
-Vagrant.guests.register(:gentoo)  { Vagrant::Guest::Gentoo }
-Vagrant.guests.register(:linux)   { Vagrant::Guest::Linux }
-Vagrant.guests.register(:openbsd) { Vagrant::Guest::OpenBSD }
-Vagrant.guests.register(:redhat)  { Vagrant::Guest::Redhat }
-Vagrant.guests.register(:solaris) { Vagrant::Guest::Solaris }
-Vagrant.guests.register(:suse)    { Vagrant::Guest::Suse }
-Vagrant.guests.register(:ubuntu)  { Vagrant::Guest::Ubuntu }
-
-# Register the built-in provisioners
-Vagrant.provisioners.register(:chef_solo)     { Vagrant::Provisioners::ChefSolo }
-Vagrant.provisioners.register(:chef_client)   { Vagrant::Provisioners::ChefClient }
-Vagrant.provisioners.register(:puppet)        { Vagrant::Provisioners::Puppet }
-Vagrant.provisioners.register(:puppet_server) { Vagrant::Provisioners::PuppetServer }
-Vagrant.provisioners.register(:shell)         { Vagrant::Provisioners::Shell }
-
-# Register the built-in systems
-Vagrant.config_keys.register(:freebsd) { Vagrant::Guest::FreeBSD::FreeBSDConfig }
-Vagrant.config_keys.register(:linux)   { Vagrant::Guest::Linux::LinuxConfig }
-Vagrant.config_keys.register(:solaris) { Vagrant::Guest::Solaris::SolarisConfig }
+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