vagrantup 1.0.7 → 1.1.0

data/lib/vagrant/config/v2/root.rb

@@ -0,0 +1,105 @@
+require "set"
+
+require "vagrant/config/v2/util"
+
+module Vagrant
+  module Config
+    module V2
+      # This is the root configuration class. An instance of this is what
+      # is passed into version 1 Vagrant configuration blocks.
+      class Root
+        # Initializes a root object that maps the given keys to specific
+        # configuration classes.
+        #
+        # @param [Hash] config_map Map of key to config class.
+        def initialize(config_map, keys=nil)
+          @keys              = keys || {}
+          @config_map        = config_map
+          @missing_key_calls = Set.new
+        end
+
+        # We use method_missing as a way to get the configuration that is
+        # used for Vagrant and load the proper configuration classes for
+        # each.
+        def method_missing(name, *args)
+          return @keys[name] if @keys.has_key?(name)
+
+          config_klass = @config_map[name.to_sym]
+          if config_klass
+            # Instantiate the class and return the instance
+            @keys[name] = config_klass.new
+            return @keys[name]
+          else
+            # Record access to a missing key as an error
+            @missing_key_calls.add(name.to_s)
+            return DummyConfig.new
+          end
+        end
+
+        # Called to finalize this object just prior to it being used by
+        # the Vagrant system. The "!" signifies that this is expected to
+        # mutate itself.
+        def finalize!
+          @keys.each do |_key, instance|
+            instance.finalize!
+          end
+        end
+
+        # This validates the configuration and returns a hash of error
+        # messages by section. If there are no errors, an empty hash
+        # is returned.
+        #
+        # @param [Environment] env
+        # @return [Hash]
+        def validate(machine)
+          # Go through each of the configuration keys and validate
+          errors = {}
+          @keys.each do |_key, instance|
+            if instance.respond_to?(:validate)
+              # Validate this single item, and if we have errors then
+              # we merge them into our total errors list.
+              result = instance.validate(machine)
+              if result && !result.empty?
+                errors = Util.merge_errors(errors, result)
+              end
+            end
+          end
+
+          # Go through and delete empty keys
+          errors.keys.each do |key|
+            errors.delete(key) if errors[key].empty?
+          end
+
+          # If we have missing keys, record those as errors
+          if !@missing_key_calls.empty?
+            errors["Vagrant"] = @missing_key_calls.to_a.sort.map do |key|
+              I18n.t("vagrant.config.root.bad_key", :key => key)
+            end
+          end
+
+          errors
+        end
+
+        # Returns the internal state of the root object. This is used
+        # by outside classes when merging, and shouldn't be called directly.
+        # Note the strange method name is to attempt to avoid any name
+        # clashes with potential configuration keys.
+        def __internal_state
+          {
+            "config_map"        => @config_map,
+            "keys"              => @keys,
+            "missing_key_calls" => @missing_key_calls
+          }
+        end
+
+        # This sets the internal state. This is used by the core to do some
+        # merging logic and shouldn't be used by the general public.
+        def __set_internal_state(state)
+          @config_map        = state["config_map"] if state.has_key?("config_map")
+          @keys              = state["keys"] if state.has_key?("keys")
+          @missing_key_calls = state["missing_key_calls"] if state.has_key?("missing_key_calls")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/v2/util.rb

@@ -0,0 +1,21 @@
+module Vagrant
+  module Config
+    module V2
+      class Util
+        # This merges two error hashes from validate methods.
+        #
+        # @param [Hash] first
+        # @param [Hash] second
+        # @return [Hash] Merged result
+        def self.merge_errors(first, second)
+          first.dup.tap do |result|
+            second.each do |key, value|
+              result[key] ||= []
+              result[key] += value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/version_base.rb

@@ -0,0 +1,80 @@
+module Vagrant
+  module Config
+    # This is the base class for any configuration versions, and includes
+    # the stub methods that configuaration versions must implement. Vagrant
+    # supports configuration versioning so that backwards compatibility can be
+    # maintained for past Vagrantfiles while newer configurations are added.
+    # Vagrant only introduces new configuration versions for major versions
+    # of Vagrant.
+    class VersionBase
+      # Returns an empty configuration object. This can be any kind of object,
+      # since it is treated as an opaque value on the other side, used only
+      # for things like calling into {merge}.
+      #
+      # @return [Object]
+      def self.init
+        raise NotImplementedError
+      end
+
+      # This is called just before configuration loading is complete of
+      # a potentially completely-merged value to perform final touch-ups
+      # to the configuration, if required.
+      #
+      # This is an optional method to implement. The default implementation
+      # will simply return the same object.
+      #
+      # This will ONLY be called if this is the version that is being
+      # used. In the case that an `upgrade` is called, this will never
+      # be called.
+      #
+      # @param [Object] obj Final configuration object.
+      # @param [Object] Finalized configuration object.
+      def self.finalize(obj)
+        obj
+      end
+
+      # Loads the configuration for the given proc and returns a configuration
+      # object. The return value is treated as an opaque object, so it can be
+      # anything you'd like. The return value is the object that is passed
+      # into methods like {merge}, so it should be something you expect.
+      #
+      # @param [Proc] proc The proc that is to be configured.
+      # @return [Object]
+      def self.load(proc)
+        raise NotImplementedError
+      end
+
+      # Merges two configuration objects, returning the merged object.
+      # The values of `old` and `new` are the opaque objects returned by
+      # {load} or {init}.
+      #
+      # Once again, the return object is treated as an opaque value by
+      # the Vagrant configuration loader, so it can be anything you'd like.
+      #
+      # @param [Object] old Old configuration object.
+      # @param [Object] new New configuration object.
+      # @return [Object] The merged configuration object.
+      def self.merge(old, new)
+        raise NotImplementedError
+      end
+
+      # This is called if a previous version of configuration needs to be
+      # upgraded to this version. Each version of configuration should know
+      # how to upgrade the version immediately prior to it. This should be
+      # a best effort upgrade that makes many assumptions. The goal is for
+      # this to work in almost every case, but perhaps with some warnings.
+      # The return value for this is a 3-tuple: `[object, warnings, errors]`,
+      # where `object` is the upgraded configuration object, `warnings` is
+      # an array of warning messages, and `errors` is an array of error
+      # messages.
+      #
+      # @param [Object] old The version of the configuration object just
+      #   prior to this one.
+      # @return [Array] The 3-tuple result. Please see the above documentation
+      #   for more information on the exact structure of this object.
+      def self.upgrade(old)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/vagrant/downloaders/base.rb

@@ -14,9 +14,6 @@ module Vagrant
       # handle.
       def self.match?(url); false; end
 
-      # Called prior to execution so any error checks can be done
-      def prepare(source_url); end
-
       # Downloads the source file to the destination file. It is up to
       # implementors of this class to handle the logic.
       def download!(source_url, destination_file); end

data/lib/vagrant/downloaders/file.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'uri'
 
 module Vagrant
   module Downloaders
@@ -6,14 +7,19 @@ module Vagrant
     # simply does a file copy.
     class File < Base
       def self.match?(uri)
-        ::File.file?(::File.expand_path(uri))
-      end
+        extracted = URI.extract(uri, "file")
 
-      def prepare(source_url)
-        raise Errors::DownloaderFileDoesntExist if !::File.file?(::File.expand_path(source_url))
+        # We match if we got a file URI. It doesn't matter here if the file
+        # doesn't exist because we check again later as well.
+        return true if extracted && extracted.include?(uri)
+
+        # Otherwise we match if the file exists
+        return ::File.file?(::File.expand_path(uri))
       end
 
       def download!(source_url, destination_file)
+        raise Errors::DownloaderFileDoesntExist if !::File.file?(::File.expand_path(source_url))
+
         @ui.info I18n.t("vagrant.downloaders.file.download")
         FileUtils.cp(::File.expand_path(source_url), destination_file.path)
       end

data/lib/vagrant/downloaders/http.rb

@@ -10,7 +10,7 @@ module Vagrant
     class HTTP < Base
       def self.match?(uri)
         # URI.parse barfs on '<drive letter>:\\files \on\ windows'
-        extracted = URI.extract(uri).first
+        extracted = URI.extract(uri, ['http', 'https']).first
         extracted && extracted.include?(uri)
       end
 
@@ -69,6 +69,10 @@ module Vagrant
             @ui.clear_line
           end
         end
+      rescue Errno::ECONNRESET
+        raise Errors::DownloaderHTTPConnectReset
+      rescue Errno::ETIMEDOUT
+        raise Errors::DownloaderHTTPConnectTimeout
       rescue SocketError
         raise Errors::DownloaderHTTPSocketError
       end
@@ -78,19 +82,34 @@ module Vagrant
       # This method respects the "http_proxy" and "no_proxy" environmental
       # variables so that HTTP proxies can properly be used with Vagrant.
       def resolve_proxy(source_uri)
-        proxy_string = ENV["http_proxy"] || ""
-        if !proxy_string.empty? && ENV.has_key?("no_proxy")
-          # Respect the "no_proxy" environmental variable which contains a list
-          # of hosts that a proxy should not be used for.
-          ENV["no_proxy"].split(",").each do |host|
-            if source_uri.host =~ /#{Regexp.quote(host.strip)}$/
-              proxy_string = ""
-              break
+        # Get the proper proxy key depending on the scheme of the box URL
+        proxy_key    = "#{source_uri.scheme}_proxy".downcase
+        proxy_string = ENV[proxy_key] || ENV[proxy_key.upcase] || ""
+
+        if !proxy_string.empty?
+          # Make sure the proxy string starts with a protocol so that
+          # URI.parse works properly below.
+          proxy_string = "http://#{proxy_string}" if !proxy_string.include?("://")
+
+          if ENV.has_key?("no_proxy")
+            # Respect the "no_proxy" environmental variable which contains a list
+            # of hosts that a proxy should not be used for.
+            ENV["no_proxy"].split(",").each do |host|
+              if source_uri.host =~ /#{Regexp.quote(host.strip)}$/
+                proxy_string = ""
+                break
+              end
             end
           end
         end
 
-        URI.parse(proxy_string)
+        begin
+          URI.parse(proxy_string)
+        rescue URI::InvalidURIError
+          # If we have an invalid URI, we assume the proxy is invalid,
+          # so we don't use a proxy.
+          URI.parse("")
+        end
       end
     end
   end

data/lib/vagrant/environment.rb

@@ -1,8 +1,9 @@
-require 'pathname'
 require 'fileutils'
+require 'json'
+require 'pathname'
+require 'set'
 
 require 'log4r'
-require 'rubygems'  # This is needed for plugin loading below.
 
 require 'vagrant/util/file_mode'
 require 'vagrant/util/platform'
@@ -12,23 +13,36 @@ module Vagrant
   # defined as basically a folder with a "Vagrantfile." This class allows
   # access to the VMs, CLI, etc. all in the scope of this environment.
   class Environment
-    HOME_SUBDIRS = ["tmp", "boxes", "gems"]
-    DEFAULT_VM = :default
     DEFAULT_HOME = "~/.vagrant.d"
+    DEFAULT_LOCAL_DATA = ".vagrant"
 
     # The `cwd` that this environment represents
     attr_reader :cwd
 
+    # The persistent data directory where global data can be stored. It
+    # is up to the creator of the data in this directory to properly
+    # remove it when it is no longer needed.
+    #
+    # @return [Pathname]
+    attr_reader :data_dir
+
     # The valid name for a Vagrantfile for this environment.
     attr_reader :vagrantfile_name
 
     # The {UI} object to communicate with the outside world.
     attr_reader :ui
 
+    # This is the UI class to use when creating new UIs.
+    attr_reader :ui_class
+
     # The directory to the "home" folder that Vagrant will use to store
     # global state.
     attr_reader :home_path
 
+    # The directory to the directory where local, environment-specific
+    # data is stored.
+    attr_reader :local_data_path
+
     # The directory where temporary files for Vagrant go.
     attr_reader :tmp_path
 
@@ -49,10 +63,11 @@ module Vagrant
     def initialize(opts=nil)
       opts = {
         :cwd => nil,
-        :vagrantfile_name => nil,
+        :home_path => nil,
+        :local_data_path => nil,
         :lock_path => nil,
         :ui_class => nil,
-        :home_path => nil
+        :vagrantfile_name => nil
       }.merge(opts || {})
 
       # Set the default working directory to look for the vagrantfile
@@ -61,22 +76,25 @@ module Vagrant
       opts[:cwd] = Pathname.new(opts[:cwd])
       raise Errors::EnvironmentNonExistentCWD if !opts[:cwd].directory?
 
+      # Set the default ui class
+      opts[:ui_class] ||= UI::Silent
+
       # Set the Vagrantfile name up. We append "Vagrantfile" and "vagrantfile" so that
       # those continue to work as well, but anything custom will take precedence.
-      opts[:vagrantfile_name] ||= []
-      opts[:vagrantfile_name] = [opts[:vagrantfile_name]] if !opts[:vagrantfile_name].is_a?(Array)
-      opts[:vagrantfile_name] += ["Vagrantfile", "vagrantfile"]
+      opts[:vagrantfile_name] ||= ENV["VAGRANT_VAGRANTFILE"] if \
+        ENV.has_key?("VAGRANT_VAGRANTFILE")
+      opts[:vagrantfile_name] ||= ["Vagrantfile", "vagrantfile"]
+      opts[:vagrantfile_name] = [opts[:vagrantfile_name]] if \
+        !opts[:vagrantfile_name].is_a?(Array)
 
       # Set instance variables for all the configuration parameters.
-      @cwd    = opts[:cwd]
+      @cwd              = opts[:cwd]
+      @home_path        = opts[:home_path]
+      @lock_path        = opts[:lock_path]
       @vagrantfile_name = opts[:vagrantfile_name]
-      @lock_path = opts[:lock_path]
-      @home_path = opts[:home_path]
-
-      ui_class = opts[:ui_class] || UI::Silent
-      @ui      = ui_class.new("vagrant")
+      @ui               = opts[:ui_class].new
+      @ui_class         = opts[:ui_class]
 
-      @loaded = false
       @lock_acquired = false
 
       @logger = Log4r::Logger.new("vagrant::environment")
@@ -85,9 +103,22 @@ module Vagrant
 
       # Setup the home directory
       setup_home_path
-      @tmp_path = @home_path.join("tmp")
       @boxes_path = @home_path.join("boxes")
+      @data_dir   = @home_path.join("data")
       @gems_path  = @home_path.join("gems")
+      @tmp_path   = @home_path.join("tmp")
+
+      # Setup the local data directory. If a configuration path is given,
+      # then it is expanded relative to the working directory. Otherwise,
+      # we use the default which is expanded relative to the root path.
+      @local_data_path = nil
+      if opts[:local_data_path]
+        @local_data_path = Pathname.new(File.expand_path(opts[:local_data_path], @cwd))
+      elsif !root_path.nil?
+        @local_data_path = root_path.join(DEFAULT_LOCAL_DATA)
+      end
+
+      setup_local_data_path
 
       # Setup the default private key
       @default_private_key_path = @home_path.join("insecure_private_key")
@@ -95,67 +126,275 @@ module Vagrant
 
       # Load the plugins
       load_plugins
+
+      # Call the environment load hooks
+      hook(:environment_load)
+    end
+
+    # Return a human-friendly string for pretty printed or inspected
+    # instances.
+    #
+    # @return [String]
+    def inspect
+      "#<#{self.class}: #{@cwd}>"
     end
 
     #---------------------------------------------------------------
     # Helpers
     #---------------------------------------------------------------
 
-    # The path to the `dotfile`, which contains the persisted UUID of
-    # the VM if it exists.
+    # Returns a list of machines that this environment is currently
+    # managing that physically have been created.
     #
-    # @return [Pathname]
-    def dotfile_path
-      return nil if !root_path
-      root_path.join(config.global.vagrant.dotfile_name)
+    # An "active" machine is a machine that Vagrant manages that has
+    # been created. The machine itself may be in any state such as running,
+    # suspended, etc. but if a machine is "active" then it exists.
+    #
+    # Note that the machines in this array may no longer be present in
+    # the Vagrantfile of this environment. In this case the machine can
+    # be considered an "orphan." Determining which machines are orphan
+    # and which aren't is not currently a supported feature, but will
+    # be in a future version.
+    #
+    # @return [Array<String, Symbol>]
+    def active_machines
+      machine_folder = @local_data_path.join("machines")
+
+      # If the machine folder is not a directory then we just return
+      # an empty array since no active machines exist.
+      return [] if !machine_folder.directory?
+
+      # Traverse the machines folder accumulate a result
+      result = []
+
+      machine_folder.children(true).each do |name_folder|
+        # If this isn't a directory then it isn't a machine
+        next if !name_folder.directory?
+
+        name = name_folder.basename.to_s.to_sym
+        name_folder.children(true).each do |provider_folder|
+          # If this isn't a directory then it isn't a provider
+          next if !provider_folder.directory?
+
+          # If this machine doesn't have an ID, then ignore
+          next if !provider_folder.join("id").file?
+
+          provider = provider_folder.basename.to_s.to_sym
+          result << [name, provider]
+        end
+      end
+
+      # Return the results
+      result
+    end
+
+    # This returns the provider name for the default provider for this
+    # environment. The provider returned is currently hardcoded to "virtualbox"
+    # but one day should be a detected valid, best-case provider for this
+    # environment.
+    #
+    # @return [Symbol] Name of the default provider.
+    def default_provider
+      :virtualbox
     end
 
     # Returns the collection of boxes for the environment.
     #
     # @return [BoxCollection]
     def boxes
-      @_boxes ||= BoxCollection.new(boxes_path, action_runner)
+      @_boxes ||= BoxCollection.new(boxes_path)
     end
 
-    # Returns the VMs associated with this environment.
+    # This is the global config, comprised of loading configuration from
+    # the default, home, and root Vagrantfiles. This configuration is only
+    # really useful for reading the list of virtual machines, since each
+    # individual VM can override _most_ settings.
     #
-    # @return [Hash<Symbol,VM>]
-    def vms
-      load! if !loaded?
-      @vms ||= load_vms!
+    # This is lazy-loaded upon first use.
+    #
+    # @return [Object]
+    def config_global
+      return @config_global if @config_global
+
+      @logger.info("Initializing config...")
+
+      home_vagrantfile = nil
+      root_vagrantfile = nil
+      home_vagrantfile = find_vagrantfile(home_path) if home_path
+      root_vagrantfile = find_vagrantfile(root_path) if root_path
+
+      # Create the configuration loader and set the sources that are global.
+      # We use this to load the configuration, and the list of machines we are
+      # managing. Then, the actual individual configuration is loaded for
+      # each {#machine} call.
+      @config_loader = Config::Loader.new(Config::VERSIONS, Config::VERSIONS_ORDER)
+      @config_loader.set(:default, File.expand_path("config/default.rb", Vagrant.source_root))
+      @config_loader.set(:home, home_vagrantfile) if home_vagrantfile
+      @config_loader.set(:root, root_vagrantfile) if root_vagrantfile
+
+      # Make the initial call to get the "global" config. This is mostly
+      # only useful to get the list of machines that we are managing.
+      # Because of this, we ignore any warnings or errors.
+      @config_global, _ = @config_loader.load([:default, :home, :root])
+
+      # Return the config
+      @config_global
     end
 
-    # Returns the VMs associated with this environment, in the order
-    # that they were defined.
+    # This defines a hook point where plugin action hooks that are registered
+    # against the given name will be run in the context of this environment.
     #
-    # @return [Array<VM>]
-    def vms_ordered
-      return @vms.values if !multivm?
-      @vms_enum ||= config.global.vm.defined_vm_keys.map { |name| @vms[name] }
+    # @param [Symbol] name Name of the hook.
+    def hook(name)
+      @logger.info("Running hook: #{name}")
+      callable = Action::Builder.new
+      action_runner.run(
+        callable,
+        :action_name => name,
+        :env => self)
     end
 
-    # Returns the primary VM associated with this environment. This
-    # method is only applicable for multi-VM environments. This can
-    # potentially be nil if no primary VM is specified.
+    # This returns a machine with the proper provider for this environment.
+    # The machine named by `name` must be in this environment.
     #
-    # @return [VM]
-    def primary_vm
-      return vms.values.first if !multivm?
+    # @param [Symbol] name Name of the machine (as configured in the
+    #   Vagrantfile).
+    # @param [Symbol] provider The provider that this machine should be
+    #   backed by.
+    # @param [Boolean] refresh If true, then if there is a cached version
+    #   it is reloaded.
+    # @return [Machine]
+    def machine(name, provider, refresh=false)
+      @logger.info("Getting machine: #{name} (#{provider})")
+
+      # Compose the cache key of the name and provider, and return from
+      # the cache if we have that.
+      cache_key = [name, provider]
+      @machines ||= {}
+      if refresh
+        @logger.info("Refreshing machine (busting cache): #{name} (#{provider})")
+        @machines.delete(cache_key)
+      end
+
+      if @machines.has_key?(cache_key)
+        @logger.info("Returning cached machine: #{name} (#{provider})")
+        return @machines[cache_key]
+      end
 
-      config.global.vm.defined_vms.each do |name, subvm|
-        return vms[name] if subvm.options[:primary]
+      @logger.info("Uncached load of machine.")
+      sub_vm = config_global.vm.defined_vms[name]
+      if !sub_vm
+        raise Errors::MachineNotFound, :name => name, :provider => provider
       end
 
+      provider_cls = Vagrant.plugin("2").manager.providers[provider]
+      if !provider_cls
+        raise Errors::ProviderNotFound, :machine => name, :provider => provider
+      end
+
+      # Build the machine configuration. This requires two passes: The first pass
+      # loads in the machine sub-configuration. Since this can potentially
+      # define a new box to base the machine from, we then make a second pass
+      # with the box Vagrantfile (if it has one).
+      vm_config_key = "vm_#{name}".to_sym
+      @config_loader.set(vm_config_key, sub_vm.config_procs)
+      config, config_warnings, config_errors = \
+        @config_loader.load([:default, :home, :root, vm_config_key])
+
+      box = nil
+      begin
+        box = boxes.find(config.vm.box, provider)
+      rescue Errors::BoxUpgradeRequired
+        # Upgrade the box if we must
+        @logger.info("Upgrading box during config load: #{config.vm.box}")
+        boxes.upgrade(config.vm.box)
+        retry
+      end
+
+      # If a box was found, then we attempt to load the Vagrantfile for
+      # that box. We don't require a box since we allow providers to download
+      # boxes and so on.
+      if box
+        box_vagrantfile = find_vagrantfile(box.directory)
+        if box_vagrantfile
+          # The box has a custom Vagrantfile, so we load that into the config
+          # as well.
+          @logger.info("Box exists with Vagrantfile. Reloading machine config.")
+          box_config_key = "box_#{box.name}_#{box.provider}".to_sym
+          @config_loader.set(box_config_key, box_vagrantfile)
+          config, config_warnings, config_errors = \
+            @config_loader.load([:default, box_config_key, :home, :root, vm_config_key])
+        end
+      end
+
+      # Get the provider configuration from the final loaded configuration
+      provider_config = config.vm.get_provider_config(provider)
+
+      # Determine the machine data directory and pass it to the machine.
+      # XXX: Permissions error here.
+      machine_data_path = @local_data_path.join("machines/#{name}/#{provider}")
+      FileUtils.mkdir_p(machine_data_path)
+
+      # If there were warnings or errors we want to output them
+      if !config_warnings.empty? || !config_errors.empty?
+        # The color of the output depends on whether we have warnings
+        # or errors...
+        level  = config_errors.empty? ? :warn : :error
+        output = Util::TemplateRenderer.render(
+          "config/messages",
+          :warnings => config_warnings,
+          :errors => config_errors).chomp
+        @ui.send(level, I18n.t("vagrant.general.config_upgrade_messages",
+                              :output => output))
+
+        # If we had errors, then we bail
+        raise Errors::ConfigUpgradeErrors if !config_errors.empty?
+      end
+
+      # Create the machine and cache it for future calls. This will also
+      # return the machine from this method.
+      @machines[cache_key] = Machine.new(name, provider, provider_cls, provider_config,
+                                         config, machine_data_path, box, self)
+    end
+
+    # This returns a list of the configured machines for this environment.
+    # Each of the names returned by this method is valid to be used with
+    # the {#machine} method.
+    #
+    # @return [Array<Symbol>] Configured machine names.
+    def machine_names
+      config_global.vm.defined_vm_keys.dup
+    end
+
+    # This returns the name of the machine that is the "primary." In the
+    # case of  a single-machine environment, this is just the single machine
+    # name. In the case of a multi-machine environment, then this can
+    # potentially be nil if no primary machine is specified.
+    #
+    # @return [Symbol]
+    def primary_machine_name
+      # If it is a single machine environment, then return the name
+      return machine_names.first if machine_names.length == 1
+
+      # If it is a multi-machine environment, then return the primary
+      config_global.vm.defined_vms.each do |name, subvm|
+        return name if subvm.options[:primary]
+      end
+
+      # If no primary was specified, nil it is
       nil
     end
 
-    # Returns a boolean whether this environment represents a multi-VM
-    # environment or not. This will work even when called on child
-    # environments.
+    # Unload the environment, running completion hooks. The environment
+    # should not be used after this (but CAN be, technically). It is
+    # recommended to always immediately set the variable to `nil` after
+    # running this so you can't accidentally run any more methods. Example:
+    #
+    #     env.unload
+    #     env = nil
     #
-    # @return [Bool]
-    def multivm?
-      vms.length > 1 || vms.keys.first != DEFAULT_VM
+    def unload
+      hook(:environment_unload)
     end
 
     # Makes a call to the CLI with the given arguments as if they
@@ -169,7 +408,7 @@ module Vagrant
 
     # Returns the host object associated with this environment.
     #
-    # @return [Hosts::Base]
+    # @return [Class]
     def host
       return @host if defined?(@host)
 
@@ -177,12 +416,16 @@ module Vagrant
       # matters here, so please don't touch. Specifically: The symbol
       # check is done after the detect check because the symbol check
       # will return nil, and we don't want to trigger a detect load.
-      host_klass = config.global.vagrant.host
-      host_klass = Hosts.detect(Vagrant.hosts) if host_klass.nil? || host_klass == :detect
-      host_klass = Vagrant.hosts.get(host_klass) if host_klass.is_a?(Symbol)
+      host_klass = config_global.vagrant.host
+      if host_klass.nil? || host_klass == :detect
+        hosts = Vagrant.plugin("2").manager.hosts.to_hash
+
+        # Get the flattened list of available hosts
+        host_klass = Hosts.detect(hosts)
+      end
 
       # If no host class is detected, we use the base class.
-      host_klass ||= Hosts::Base
+      host_klass ||= Vagrant.plugin("2", :host)
 
       @host ||= host_klass.new(@ui)
     end
@@ -191,12 +434,14 @@ module Vagrant
     #
     # @return [Action::Runner]
     def action_runner
-      @action_runner ||= Action::Runner.new(action_registry) do
+      @action_runner ||= Action::Runner.new do
         {
           :action_runner  => action_runner,
           :box_collection => boxes,
-          :global_config  => config.global,
+          :global_config  => config_global,
           :host           => host,
+          :gems_path      => gems_path,
+          :home_path      => home_path,
           :root_path      => root_path,
           :tmp_path       => tmp_path,
           :ui             => @ui
@@ -204,37 +449,6 @@ module Vagrant
       end
     end
 
-    # Action registry for registering new actions with this environment.
-    #
-    # @return [Registry]
-    def action_registry
-      # For now we return the global built-in actions registry. In the future
-      # we may want to create an isolated registry that inherits from this
-      # global one, but for now there isn't a use case that calls for it.
-      Vagrant.actions
-    end
-
-    # Loads on initial access and reads data from the global data store.
-    # The global data store is global to Vagrant everywhere (in every environment),
-    # so it can be used to store system-wide information. Note that "system-wide"
-    # typically means "for this user" since the location of the global data
-    # store is in the home directory.
-    #
-    # @return [DataStore]
-    def global_data
-      @global_data ||= DataStore.new(File.expand_path("global_data.json", home_path))
-    end
-
-    # Loads (on initial access) and reads data from the local data
-    # store. This file is always at the root path as the file "~/.vagrant"
-    # and contains a JSON dump of a hash. See {DataStore} for more
-    # information.
-    #
-    # @return [DataStore]
-    def local_data
-      @local_data ||= DataStore.new(dotfile_path)
-    end
-
     # The root path is the path where the top-most (loaded last)
     # Vagrantfile resides. It can be considered the project root for
     # this environment.
@@ -291,152 +505,10 @@ module Vagrant
       end
     end
 
-    #---------------------------------------------------------------
-    # Config Methods
-    #---------------------------------------------------------------
-
-    # The configuration object represented by this environment. This
-    # will trigger the environment to load if it hasn't loaded yet (see
-    # {#load!}).
-    #
-    # @return [Config::Container]
-    def config
-      load! if !loaded?
-      @config
-    end
-
     #---------------------------------------------------------------
     # Load Methods
     #---------------------------------------------------------------
 
-    # Returns a boolean representing if the environment has been
-    # loaded or not.
-    #
-    # @return [Bool]
-    def loaded?
-      !!@loaded
-    end
-
-    # Loads this entire environment, setting up the instance variables
-    # such as `vm`, `config`, etc. on this environment. The order this
-    # method calls its other methods is very particular.
-    def load!
-      if !loaded?
-        @loaded = true
-        @logger.info("Loading configuration...")
-        load_config!
-      end
-
-      self
-    end
-
-    # Reloads the configuration of this environment.
-    def reload!
-      # Reload the configuration
-      load_config!
-
-      # Clear the VMs because this can now be diferent due to configuration
-      @vms = nil
-    end
-
-    # Loads this environment's configuration and stores it in the {#config}
-    # variable. The configuration loaded by this method is specified to
-    # this environment, meaning that it will use the given root directory
-    # to load the Vagrantfile into that context.
-    def load_config!
-      # Initialize the config loader
-      config_loader = Config::Loader.new
-      config_loader.load_order = [:default, :box, :home, :root, :vm]
-
-      inner_load = lambda do |*args|
-        # This is for Ruby 1.8.7 compatibility. Ruby 1.8.7 doesn't allow
-        # default arguments for lambdas, so we get around by doing a *args
-        # and setting the args here.
-        subvm = args[0]
-        box   = args[1]
-
-        # Default Vagrantfile first. This is the Vagrantfile that ships
-        # with Vagrant.
-        config_loader.set(:default, File.expand_path("config/default.rb", Vagrant.source_root))
-
-        if box
-          # We load the box Vagrantfile
-          box_vagrantfile = find_vagrantfile(box.directory)
-          config_loader.set(:box, box_vagrantfile) if box_vagrantfile
-        end
-
-        if home_path
-          # Load the home Vagrantfile
-          home_vagrantfile = find_vagrantfile(home_path)
-          config_loader.set(:home, home_vagrantfile) if home_vagrantfile
-        end
-
-        if root_path
-          # Load the Vagrantfile in this directory
-          root_vagrantfile = find_vagrantfile(root_path)
-          config_loader.set(:root, root_vagrantfile) if root_vagrantfile
-        end
-
-        if subvm
-          # We have subvm configuration, so set that up as well.
-          config_loader.set(:vm, subvm.proc_stack)
-        end
-
-        # Execute the configuration stack and store the result as the final
-        # value in the config ivar.
-        config_loader.load
-      end
-
-      # For the global configuration, we only need to load the configuration
-      # in a single pass, since nothing is conditional on the configuration.
-      global = inner_load.call
-
-      # For each virtual machine represented by this environment, we have
-      # to load the configuration in two-passes. We do this because the
-      # first pass is used to determine the box for the VM. The second pass
-      # is used to also load the box Vagrantfile.
-      defined_vm_keys = global.vm.defined_vm_keys.dup
-      defined_vms     = global.vm.defined_vms.dup
-
-      # If this isn't a multi-VM environment, then setup the default VM
-      # to simply be our configuration.
-      if defined_vm_keys.empty?
-        defined_vm_keys << DEFAULT_VM
-        defined_vms[DEFAULT_VM] = Config::VMConfig::SubVM.new
-      end
-
-      vm_configs = defined_vm_keys.map do |vm_name|
-        @logger.debug("Loading configuration for VM: #{vm_name}")
-
-        subvm = defined_vms[vm_name]
-
-        # First pass, first run.
-        config = inner_load[subvm]
-
-        # Second pass, with the box
-        config = inner_load[subvm, boxes.find(config.vm.box)]
-        config.vm.name = vm_name
-
-        # Return the final configuration for this VM
-        config
-      end
-
-      # Finally, we have our configuration. Set it and forget it.
-      @config = Config::Container.new(global, vm_configs)
-    end
-
-    # Loads the persisted VM (if it exists) for this environment.
-    def load_vms!
-      result = {}
-
-      # Load all the virtual machine instances.
-      config.vms.each do |name|
-        result[name] = Vagrant::VM.new(name, self, config.for_vm(name))
-      end
-
-      result
-    end
-
     # This sets the `@home_path` variable properly.
     #
     # @return [Pathname]
@@ -446,14 +518,11 @@ module Vagrant
                                                  DEFAULT_HOME))
       @logger.info("Home path: #{@home_path}")
 
-      # If the setup_version file exists, then we can't load because we're
-      # not forward compatible. It means they ran a future version of Vagrant.
-      raise Errors::IncompatibleWithFutureVersion, :path => @home_path.to_s if \
-        @home_path.join("setup_version").file?
-
-      # Setup the array of necessary home directories
-      dirs = [@home_path]
-      dirs += HOME_SUBDIRS.collect { |subdir| @home_path.join(subdir) }
+      # Setup the list of child directories that need to be created if they
+      # don't already exist.
+      dirs    = [@home_path]
+      subdirs = ["boxes", "data", "gems", "rgloader", "tmp"]
+      dirs    += subdirs.collect { |subdir| @home_path.join(subdir) }
 
       # Go through each required directory, creating it if it doesn't exist
       dirs.each do |dir|
@@ -466,6 +535,49 @@ module Vagrant
           raise Errors::HomeDirectoryNotAccessible, :home_path => @home_path.to_s
         end
       end
+
+      # Create the version file to mark the version of the home directory
+      # we're using.
+      version_file = @home_path.join("setup_version")
+      if !version_file.file?
+        @logger.debug("Setting up the version file.")
+        version_file.open("w") do |f|
+          f.write("1.1")
+        end
+      end
+
+      # Create the rgloader/loader file so we can use encoded files.
+      loader_file = @home_path.join("rgloader", "loader.rb")
+      if !loader_file.file?
+        source_loader = Vagrant.source_root.join("templates/rgloader.rb")
+        FileUtils.cp(source_loader.to_s, loader_file.to_s)
+      end
+    end
+
+    # This creates the local data directory and show an error if it
+    # couldn't properly be created.
+    def setup_local_data_path
+      if @local_data_path.nil?
+        @logger.warn("No local data path is set. Local data cannot be stored.")
+        return
+      end
+
+      @logger.info("Local data path: #{@local_data_path}")
+
+      # If the local data path is a file, then we are probably seeing an
+      # old (V1) "dotfile." In this case, we upgrade it. The upgrade process
+      # will remove the old data file if it is successful.
+      if @local_data_path.file?
+        upgrade_v1_dotfile(@local_data_path)
+      end
+
+      begin
+        @logger.debug("Creating: #{@local_data_path}")
+        FileUtils.mkdir_p(@local_data_path)
+      rescue Errno::EACCES
+        raise Errors::LocalDataDirectoryNotAccessible,
+          :local_data_path => @local_data_path.to_s
+      end
     end
 
     protected
@@ -480,8 +592,17 @@ module Vagrant
     def copy_insecure_private_key
       if !@default_private_key_path.exist?
         @logger.info("Copying private key to home directory")
-        FileUtils.cp(File.expand_path("keys/vagrant", Vagrant.source_root),
-                     @default_private_key_path)
+
+        source      = File.expand_path("keys/vagrant", Vagrant.source_root)
+        destination = @default_private_key_path
+
+        begin
+          FileUtils.cp(source, destination)
+        rescue Errno::EACCES
+          raise Errors::CopyPrivateKeyFailed,
+            :source => source,
+            :destination => destination
+        end
       end
 
       if !Util::Platform.windows?
@@ -510,13 +631,99 @@ module Vagrant
     # Loads the Vagrant plugins by properly setting up RubyGems so that
     # our private gem repository is on the path.
     def load_plugins
+      if ENV["VAGRANT_NO_PLUGINS"]
+        # If this key exists, then we don't load any plugins. It is a "safe
+        # mode" of sorts.
+        @logger.warn("VAGRANT_NO_PLUGINS is set. Not loading 3rd party plugins.")
+        return
+      end
+
       # Add our private gem path to the gem path and reset the paths
       # that Rubygems knows about.
       ENV["GEM_PATH"] = "#{@gems_path}#{::File::PATH_SEPARATOR}#{ENV["GEM_PATH"]}"
       ::Gem.clear_paths
 
       # Load the plugins
-      Plugin.load!
+      plugins_json_file = @home_path.join("plugins.json")
+      @logger.debug("Loading plugins from: #{plugins_json_file}")
+      if plugins_json_file.file?
+        data = JSON.parse(plugins_json_file.read)
+        data["installed"].each do |plugin|
+          @logger.info("Loading plugin from JSON: #{plugin}")
+          begin
+            Vagrant.require_plugin(plugin)
+          rescue Errors::PluginLoadError => e
+            @ui.error(e.message + "\n")
+          rescue Errors::PluginLoadFailed => e
+            @ui.error(e.message + "\n")
+          end
+        end
+      end
+    end
+
+    # This upgrades a Vagrant 1.0.x "dotfile" to the new V2 format.
+    #
+    # This is a destructive process. Once the upgrade is complete, the
+    # old dotfile is removed, and the environment becomes incompatible for
+    # Vagrant 1.0 environments.
+    #
+    # @param [Pathname] path The path to the dotfile
+    def upgrade_v1_dotfile(path)
+      @logger.info("Upgrading V1 dotfile to V2 directory structure...")
+
+      # First, verify the file isn't empty. If it is an empty file, we
+      # just delete it and go on with life.
+      contents = path.read.strip
+      if contents.strip == ""
+        @logger.info("V1 dotfile was empty. Removing and moving on.")
+        path.delete
+        return
+      end
+
+      # Otherwise, verify there is valid JSON in here since a Vagrant
+      # environment would always ensure valid JSON. This is a sanity check
+      # to make sure we don't nuke a dotfile that is not ours...
+      @logger.debug("Attempting to parse JSON of V1 file")
+      json_data = nil
+      begin
+        json_data = JSON.parse(contents)
+        @logger.debug("JSON parsed successfully. Things are okay.")
+      rescue JSON::ParserError
+        # The file could've been tampered with since Vagrant 1.0.x is
+        # supposed to ensure that the contents are valid JSON. Show an error.
+        raise Errors::DotfileUpgradeJSONError,
+          :state_file => path.to_s
+      end
+
+      # Alright, let's upgrade this guy to the new structure. Start by
+      # backing up the old dotfile.
+      backup_file = path.dirname.join(".vagrant.v1.#{Time.now.to_i}")
+      @logger.info("Renaming old dotfile to: #{backup_file}")
+      path.rename(backup_file)
+
+      # Now, we create the actual local data directory. This should succeed
+      # this time since we renamed the old conflicting V1.
+      setup_local_data_path
+
+      if json_data["active"]
+        @logger.debug("Upgrading to V2 style for each active VM")
+        json_data["active"].each do |name, id|
+          @logger.info("Upgrading dotfile: #{name} (#{id})")
+
+          # Create the machine configuration directory
+          directory = @local_data_path.join("machines/#{name}/virtualbox")
+          FileUtils.mkdir_p(directory)
+
+          # Write the ID file
+          directory.join("id").open("w+") do |f|
+            f.write(id)
+          end
+        end
+      end
+
+      # Upgrade complete! Let the user know
+      @ui.info(I18n.t("vagrant.general.upgraded_v1_dotfile",
+                     :backup_path => backup_file.to_s))
     end
   end
 end