vagrantup 1.0.7 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af5a4fbac1196e53c4539fa34d8680793d789245
-  data.tar.gz: 2c8ac719a48f962be8604775953f745003cad31a
+  metadata.gz: 5792b5a7710c5518a4358d532a1746f69e612bd6
+  data.tar.gz: cb084ce778ebfd587cb8d034d1dccde6e2fc71b6
 SHA512:
-  metadata.gz: 1cc988d087d62e496054eccba11ce65ec7fe9f8dbce697ee83eafd0634d1f60ffb44863ac1210dd6a0012c6d78306896fc7d96a5c0bd17cc7a926da5068617c8
-  data.tar.gz: 66ac85e05e6c84c2cbf8413b4495b5502578bc736f244a2862f1601b1c1770a70b0c4bae75d19aed2c62efc5e28bcb19860cd28da2dc19677d949bcf0dbeae78
+  metadata.gz: a53f20097b36bbb85ac603e5ed8eb3a33ab03ff1f8ce1e505ffe096d7316d36f46eedd22e0e7a08c1cab6c3a24155ef20efcc84bb5da12be7ce7b77711ed8c3b
+  data.tar.gz: 82d177f84a3c71102b174f7a88d890e7e2a57ae93a0aa01163fda1923be2a7a1a439e398bf9c87b5d17adf5491009e35e6972238f5028c85e6ed7a837ea7f18b

data/CHANGELOG.md

@@ -1,3 +1,94 @@
+## 1.1.0 (March 14, 2013)
+
+BACKWARDS INCOMPATIBILITIES:
+
+  - Vagrantfiles from 1.0.x that _do not use_ any plugins are fully
+    backwards compatible. If plugins are used, they must be removed prior
+    to upgrading. The new plugin system in place will avoid this issue in
+    the future.
+  - Lots of changes introduced in the form of a new configuration version and
+    format, but this is _opt-in_. Old Vagrantfile format continues to be supported,
+    as promised. To use the new features that will be introduced throughout
+    the 1.x series, you'll have to upgrade at some point.
+
+FEATURES:
+
+  - Groundwork for **providers**, alternate backends for Vagrant that
+    allow Vagrant to power systems other than VirtualBox. Much improvement
+    and change will come to this throughout the 1.x lifecycle. The API
+    will continue to change, features will be added, and more. Specifically,
+    a revamped system for handling shared folders gracefully across providers
+    will be introduced in a future release.
+  - New plugin system which adds much more structure and stability to
+    the overall API. The goal of this system is to make it easier to write
+    powerful plugins for Vagrant while providing a backwards-compatible API
+    so that plugins will always _load_ (though they will almost certainly
+    not be _functional_ in future versions of Vagrant).
+  - Plugins are now installed and managed using the `vagrant plugin` interface.
+  - Allow "file://" URLs for box URLs. [GH-1087]
+  - Emit "vagrant-mount" upstart event when NFS shares are mounted. [GH-1118]
+  - Add a VirtualBox provider config `auto_nat_dns_proxy` which when set to
+    false will not attempt to automatically manage NAT DNS proxy settings
+    with VirtualBox. [GH-1313]
+  - `vagrant provision` accepts the `--provision-with` flag [GH-1167]
+  - Set the name of VirtualBox machines with `virtualbox.name` in the
+    VirtualBox provider config. [GH-1126]
+  - `vagrant ssh` will execute an `ssh` binary on Windows if it is on
+    your PATH. [GH-933]
+  - The environmental variable `VAGRANT_VAGRANTFILE` can be used to
+    specify an alternate Vagrantfile filename.
+
+IMPROVEMENTS / BUG FIXES:
+
+  - Vagrant works much better in Cygwin environments on Windows by
+    properly resolving Cygwin paths. [GH-1366]
+  - Improve the SSH "ready?" check by more gracefully handling timeouts. [GH-841]
+  - Human friendly error if connection times out for HTTP downloads. [GH-849]
+  - Detect when the VirtualBox installation is incomplete and error. [GH-846]
+  - Detect when kernel modules for VirtualBox need to be installed on Gentoo
+    systems and report a user-friendly error. [GH-710]
+  - All `vagrant` commands that can take a target VM name can take one even
+    if you're not in a multi-VM environment. [GH-894]
+  - Hostname is set before networks are setup to avoid very slow `sudo`
+    speeds on CentOS. [GH-922]
+  - `config.ssh.shell` now includes the flags to pass to it, such as `-l` [GH-917]
+  - The check for whether a port is open or not is more complete by
+    catching ENETUNREACH errors. [GH-948]
+  - SSH uses LogLevel FATAL so that errors are still shown.
+  - Sending a SIGINT (Ctrl-C) very early on when executing `vagrant` no
+    longer results in an ugly stack trace.
+  - Chef JSON configuration output is now pretty-printed to be
+    human readable. [GH-1146]
+    that SSHing succeeds when booting a machine.
+  - VMs in the "guru meditation" state can be destroyed now using
+    `vagrant destroy`.
+  - Fix issue where changing SSH key permissions didn't properly work. [GH-911]
+  - Fix issue where Vagrant didn't properly detect VBoxManage on Windows
+    if VBOX_INSTALL_PATH contained multiple paths. [GH-885]
+  - Fix typo in setting host name for Gentoo guests. [GH-931]
+  - Files that are included with `vagrant package --include` now properly
+    preserve file attributes on earlier versions of Ruby. [GH-951]
+  - Multiple interfaces now work with Arch linux guests. [GH-957]
+  - Fix issue where subprocess execution would always spin CPU of Ruby
+    process to 100%. [GH-832]
+  - Fix issue where shell provisioner would sometimes never end. [GH-968]
+  - Fix issue where puppet would reorder module paths. [GH-964]
+  - When console input is asked for (destroying a VM, bridged interfaces, etc.),
+    keystrokes such as ctrl-D and ctrl-C are more gracefully handled. [GH-1017]
+  - Fixed bug where port check would use "localhost" on systems where
+    "localhost" is not available. [GH-1057]
+  - Add missing translation for "saving" state on VirtualBox. [GH-1110]
+  - Proper error message if the remote end unexpectedly resets the connection
+    while downloading a box over HTTP. [GH-1090]
+  - Human-friendly error is raised if there are permission issues when
+    using SCP to upload files. [GH-924]
+  - Box adding doesn't use `/tmp` anymore which can avoid some cross-device
+    copy issues. [GH-1199]
+  - Vagrant works properly in folders with strange characters. [GH-1223]
+  - Vagrant properly handles "paused" VirtualBox machines. [GH-1184]
+  - Better behavior around permissions issues when copying insecure
+    private key. [GH-580]
+
 ## 1.0.7 (March 13, 2013)
 
   - Detect if a newer version of Vagrant ran and error if it did,

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2010-2012Mitchell Hashimoto and John Bender
+Copyright (c) 2010-2013 Mitchell Hashimoto
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+THE SOFTWARE.

data/README.md

@@ -1,38 +1,36 @@
 # Vagrant
 
-* Website: [http://vagrantup.com](http://vagrantup.com)
+* Website: [http://www.vagrantup.com](http://www.vagrantup.com)
 * Source: [https://github.com/mitchellh/vagrant](https://github.com/mitchellh/vagrant)
 * IRC: `#vagrant` on Freenode
 * Mailing list: [Google Groups](http://groups.google.com/group/vagrant-up)
 
-Vagrant is a tool for building and distributing virtualized development environments.
+Vagrant is a tool for building and distributing development environments.
 
-By providing automated creation and provisioning of virtual machines using [Oracle’s VirtualBox](http://www.virtualbox.org),
-Vagrant provides the tools to create and configure lightweight, reproducible, and portable
-virtual environments. For more information, see the part of the getting started guide
-on “[Why Vagrant?](http://vagrantup.com/docs/getting-started/why.html)”
+Vagrant provides the framework and configuration format to create and
+manage complete portable development environments. These development
+environments can live on your computer or in the cloud, and are portable
+between Windows, Mac OS X, and Linux.
 
 ## Quick Start
 
 First, make sure your development machine has [VirtualBox](http://www.virtualbox.org)
-installed. The setup from that point forward is very easy, since Vagrant is simply
-a rubygem.
-
-    gem install vagrant
+installed. After this, [download and install the appropriate Vagrant package for your OS](http://downloads.vagrantup.com). If you're not on Mac OS X or Windows, you'll need
+to add `/opt/vagrant/bin` to your `PATH`. After this, you're ready to go!
 
 To build your first virtual environment:
 
-    vagrant init lucid32 http://files.vagrantup.com/lucid32.box
+    vagrant init precise32 http://files.vagrantup.com/precise32.box
     vagrant up
 
 Note: The above `vagrant up` command will also trigger Vagrant to download the
-`lucid32` box via the specified URL. Vagrant only does this if it detects that
+`precise32` box via the specified URL. Vagrant only does this if it detects that
 the box doesn't already exist on your system.
 
 ## Getting Started Guide
 
 To learn how to build a fully functional rails development environment, view the
-[getting started guide](http://vagrantup.com/docs/getting-started/index.html).
+[getting started guide](http://vagrantup.com/v1/docs/getting-started/index.html).
 
 ## Installing the Gem from Git
 

data/bin/vagrant

@@ -1,4 +1,10 @@
 #!/usr/bin/env ruby
+
+# Trap interrupts to quit cleanly. This will be overriden at some point
+# by Vagrant. This is made to catch any interrupts while Vagrant is
+# initializing which have historically resulted in stack traces.
+Signal.trap("INT") { exit 1 }
+
 require 'log4r'
 require 'vagrant'
 require 'vagrant/cli'
@@ -28,6 +34,17 @@ else
   opts[:ui_class] = Vagrant::UI::Colored
 end
 
+# This is kind of hacky, and I'd love to find a better way to do this, but
+# if we're accessing the plugin interface, we want to NOT load plugins
+# for this run, because they can actually interfere with the function
+# of the plugin interface.
+ARGV.each do |arg|
+  if !arg.start_with?("-")
+    ENV["VAGRANT_NO_PLUGINS"] = "1" if arg == "plugin"
+    break
+  end
+end
+
 env = nil
 begin
   # Create the environment, which is the cwd of wherever the
@@ -35,12 +52,19 @@ begin
   logger.debug("Creating Vagrant environment")
   env = Vagrant::Environment.new(opts)
 
-  # Load the environment
-  logger.debug("Loading environment")
-  env.load!
+  # If we're not in the installer, warn.
+  env.ui.warn(I18n.t("vagrant.general.not_in_installer")) if !Vagrant.in_installer?
+
+  begin
+    # Execute the CLI interface, and exit with the proper error code
+    exit_status = env.cli(ARGV)
+  ensure
+    # Unload the environment so cleanup can be done
+    env.unload
+  end
 
-  # Execute the CLI interface, and exit with the proper error code
-  exit(env.cli(ARGV))
+  # Exit with the exit status from our CLI command
+  exit(exit_status)
 rescue Vagrant::Errors::VagrantError => e
   logger.error("Vagrant experienced an error! Details:")
   logger.error(e.inspect)

data/config/default.rb

@@ -1,27 +1,32 @@
-Vagrant::Config.run do |config|
+Vagrant.configure("2") do |config|
   # default config goes here
-  config.vagrant.dotfile_name = ".vagrant"
   config.vagrant.host = :detect
 
   config.ssh.username = "vagrant"
-  config.ssh.host = "127.0.0.1"
   config.ssh.guest_port = 22
   config.ssh.max_tries = 100
-  config.ssh.timeout = 10
+  config.ssh.timeout = 30
   config.ssh.forward_agent = false
   config.ssh.forward_x11 = false
-  config.ssh.shell = "bash"
+  config.ssh.shell = "bash -l"
 
-  config.vm.auto_port_range = (2200..2250)
+  config.vm.usable_port_range = (2200..2250)
   config.vm.box_url = nil
   config.vm.base_mac = nil
-  config.vm.forward_port 22, 2222, :name => "ssh", :auto => true
-  config.vm.boot_mode = "headless"
+  config.vm.graceful_halt_retry_count = 60
+  config.vm.graceful_halt_retry_interval = 1
   config.vm.guest = :linux
 
+  # Share SSH locally by default
+  config.vm.network :forwarded_port,
+    guest: 22,
+    host: 2222,
+    id: "ssh",
+    auto_correct: true
+
   # Share the root folder. This can then be overridden by
   # other Vagrantfiles, if they wish.
-  config.vm.share_folder("v-root", "/vagrant", ".")
+  config.vm.synced_folder(".", "/vagrant", :id => "vagrant-root")
 
   config.nfs.map_uid = :auto
   config.nfs.map_gid = :auto

data/contrib/bash/completion.sh

@@ -0,0 +1,3 @@
+# Autocompletion for Vagrant just put this line in your ~/.profile or link this file into it like:
+# source /path/to/vagrant/contrib/bash/completion.sh
+complete -W "$(echo `vagrant --help | awk '/^     /{print $1}'`;)" vagrant

data/keys/README.md

@@ -1,7 +1,7 @@
 # Insecure Keypair
 
 These keys are the "insecure" public/private keypair we offer to
-[base box creators](http://vagrantup.com/docs/base_boxes.html) for use in their base boxes so that
+[base box creators](http://docs.vagrantup.com/v1/docs/base_boxes.html) for use in their base boxes so that
 vagrant installations can automatically SSH into the boxes.
 
 If you're working with a team or company or with a custom box and
@@ -13,5 +13,5 @@ and configure the private key in the Vagrantfile with
 
 If you are using Vagrant on windows, the .ppk file contained here, in the keys directory,
 has been generated from the private key and should be used to connect Putty to any VMs that 
-are leveraging the default key pair. See [guide](http://vagrantup.com/docs/getting-started/windows.html) 
-in the documentation for more details on using Putty with Vagrant.
+are leveraging the default key pair. See [guide](http://docs.vagrantup.com/v1/docs/getting-started/ssh.html) 
+in the documentation for more details on using Putty with Vagrant.

data/lib/vagrant.rb

@@ -42,9 +42,11 @@ if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != ""
   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,7 +55,12 @@ 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")
+global_logger.info("Vagrant version: #{Vagrant::VERSION}")
+
+# We need these components always so instead of an autoload we
+# just require them explicitly here.
+require "vagrant/registry"
 
 module Vagrant
   autoload :Action,        'vagrant/action'
@@ -61,28 +68,48 @@ module Vagrant
   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 :Machine,       'vagrant/machine'
+  autoload :MachineState,  'vagrant/machine_state'
   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
+  # 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 }
+  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
 
   # The source root is the path to the root directory of
@@ -91,107 +118,134 @@ module Vagrant
     @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
   end
 
-  # Global registry of commands that are available via the CLI.
+  # 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.
   #
-  # This registry is used to look up the sub-commands that are available
-  # to Vagrant.
-  def self.commands
-    @commands ||= Registry.new
-  end
-
-  # Global registry of config keys that are available.
+  # 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 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
+  # @param [String] version Version of the configuration
+  def self.configure(version, &block)
+    Config.run(version, &block)
   end
 
-  # Global registry of available host classes and shortcut symbols
-  # associated with them.
+  # 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 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
-  end
-
-  # Global registry of available guest classes and shortcut symbols
-  # associated with them.
+  # 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.
   #
-  # This registry is used to look up the shortcuts for `config.vm.guest`.
-  def self.guests
-    @guests ||= Registry.new
+  # @return [Class]
+  def self.plugin(version, component=nil)
+    # Build up the key and return a result
+    key    = version.to_sym
+    key    = [key, component.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 provisioners.
+  # This should be used instead of Ruby's built-in `require` in order to
+  # load a Vagrant plugin. This will load the given plugin by first doing
+  # a normal `require`, giving a nice error message if things go wrong,
+  # and second by verifying that a Vagrant plugin was actually defined in
+  # the process.
   #
-  # This registry is used to look up the provisioners provided for
-  # `config.vm.provision`.
-  def self.provisioners
-    @provisioners ||= Registry.new
+  # @param [String] name Name of the plugin to load.
+  def self.require_plugin(name)
+    # Redirect stdout/stderr so that we can output it in our own way.
+    previous_stderr = $stderr
+    previous_stdout = $stdout
+    $stderr = StringIO.new
+    $stdout = StringIO.new
+
+    # Attempt the normal require
+    begin
+      require name
+    rescue Exception => e
+      # Since this is a rare case, we create a one-time logger here
+      # in order to output the error
+      logger = Log4r::Logger.new("vagrant::root")
+      logger.error("Failed to load plugin: #{name}")
+      logger.error(" -- Error: #{e.inspect}")
+      logger.error(" -- Backtrace:")
+      logger.error(e.backtrace.join("\n"))
+
+      # If it is a LoadError we first try to see if it failed loading
+      # the top-level entrypoint. If so, then we report a different error.
+      if e.is_a?(LoadError)
+        # Parse the message in order to get what failed to load, and
+        # add some extra protection around if the message is different.
+        parts = e.to_s.split(" -- ", 2)
+        if parts.length == 2 && parts[1] == name
+          raise Errors::PluginLoadError, :plugin => name
+        end
+      end
+
+      # Get the string data out from the stdout/stderr captures
+      stderr = $stderr.string
+      stdout = $stdout.string
+      if !stderr.empty? || !stdout.empty?
+        raise Errors::PluginLoadFailedWithOutput,
+          :plugin => name,
+          :stderr => stderr,
+          :stdout => stdout
+      end
+
+      # And raise an error itself
+      raise Errors::PluginLoadFailed,
+        :plugin => name
+    end
+  ensure
+    $stderr = previous_stderr
+    $stdout = previous_stdout
   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 }
+# 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