vagrantup 0.5.4 → 0.6.0

data/lib/vagrant/config/base.rb

@@ -0,0 +1,67 @@
+module Vagrant
+  class Config
+    # The base class for all configuration classes. This implements
+    # basic things such as the environment instance variable which all
+    # config classes need as well as a basic `to_json` implementation.
+    class Base
+      attr_accessor :env
+
+      # Registers a subclass with the Vagrant configuration system so
+      # that it can then be used in Vagrantfiles.
+      #
+      # @param [Symbol] accessor The accessor on the main config object
+      #  that is used to access the configuration class.
+      #
+      def self.configures(accessor, klass=self)
+        Top.configures(accessor, klass)
+      end
+
+      # Loads configuration values from JSON back into the proper
+      # configuration classes. By default, this is done by simply
+      # iterating over all values in the JSON hash and assigning them
+      # to instance variables on the class.
+      def self.json_create(data)
+        data.inject(new) do |result, data|
+          key, value = data
+          result.instance_variable_set("@#{key}".to_sym, value) if key != "json_class"
+          result
+        end
+      end
+
+      # Called by {Top} after the configuration is loaded to validate
+      # the configuaration objects. Subclasses should implement this
+      # method and add any errors to the `errors` object given.
+      #
+      # @param [ErrorRecorder] errors
+      def validate(errors); end
+
+      # Converts the configuration to a raw hash by calling `#to_hash`
+      # on all instance variables (if it can) and putting them into
+      # a hash.
+      def to_hash
+        instance_variables_hash.inject({}) do |acc, data|
+          k,v = data
+          v = v.to_hash if v.respond_to?(:to_hash)
+          acc[k] = v
+          acc
+        end
+      end
+
+      # Converts to JSON, with the `json_class` field set so that when
+      # the JSON is parsed back, it can be loaded back into the proper class.
+      # See {json_create}.
+      def to_json(*a)
+        result = { 'json_class' => self.class.name }
+        result.merge(instance_variables_hash).to_json(*a)
+      end
+
+      # Returns the instance variables as a hash of key-value pairs.
+      def instance_variables_hash
+        instance_variables.inject({}) do |acc, iv|
+          acc[iv.to_s[1..-1]] = instance_variable_get(iv) unless iv.to_sym == :@env
+          acc
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/error_recorder.rb

@@ -0,0 +1,19 @@
+module Vagrant
+  class Config
+    # A class which is passed into the various {Base#validate} methods and
+    # can be used as a helper to add error messages about a single config
+    # class.
+    class ErrorRecorder
+      attr_reader :errors
+
+      def initialize
+        @errors = []
+      end
+
+      # Adds an error to the list of errors.
+      def add(message)
+        @errors << message
+      end
+    end
+  end
+end

data/lib/vagrant/config/nfs.rb

@@ -0,0 +1,10 @@
+module Vagrant
+  class Config
+    class NFSConfig < Base
+      configures :nfs
+
+      attr_accessor :map_uid
+      attr_accessor :map_gid
+    end
+  end
+end

data/lib/vagrant/config/package.rb

@@ -0,0 +1,9 @@
+module Vagrant
+  class Config
+    class PackageConfig < Base
+      configures :package
+
+      attr_accessor :name
+    end
+  end
+end

data/lib/vagrant/config/ssh.rb

@@ -0,0 +1,28 @@
+module Vagrant
+  class Config
+    class SSHConfig < Base
+      configures :ssh
+
+      attr_accessor :username
+      attr_accessor :host
+      attr_accessor :port
+      attr_accessor :forwarded_port_key
+      attr_accessor :max_tries
+      attr_accessor :timeout
+      attr_writer :private_key_path
+      attr_accessor :forward_agent
+
+      def private_key_path
+        File.expand_path(@private_key_path, env.root_path)
+      end
+
+      def validate(errors)
+        [:username, :host, :port, :forwarded_port_key, :max_tries, :timeout, :private_key_path].each do |field|
+          errors.add(I18n.t("vagrant.config.common.error_empty", :field => field)) if !instance_variable_get("@#{field}".to_sym)
+        end
+
+        errors.add(I18n.t("vagrant.config.ssh.private_key_missing", :path => private_key_path)) if !File.file?(private_key_path)
+      end
+    end
+  end
+end

data/lib/vagrant/config/vagrant.rb

@@ -0,0 +1,21 @@
+module Vagrant
+  class Config
+    class VagrantConfig < Base
+      configures :vagrant
+
+      attr_accessor :dotfile_name
+      attr_accessor :home
+      attr_accessor :host
+
+      def initialize
+        @home = nil
+      end
+
+      def validate(errors)
+        [:dotfile_name, :home, :host].each do |field|
+          errors.add(I18n.t("vagrant.config.common.error_empty", :field => field)) if !instance_variable_get("@#{field}".to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/vm.rb

@@ -0,0 +1,111 @@
+module Vagrant
+  class Config
+    class VMConfig < Base
+      configures :vm
+
+      include Util::StackedProcRunner
+
+      attr_accessor :auto_port_range
+      attr_accessor :box
+      attr_accessor :box_url
+      attr_accessor :box_ovf
+      attr_accessor :base_mac
+      attr_accessor :boot_mode
+      attr_reader :forwarded_ports
+      attr_reader :shared_folders
+      attr_reader :network_options
+      attr_reader :hd_location
+      attr_accessor :disk_image_format
+      attr_accessor :provisioner
+      attr_writer :shared_folder_uid
+      attr_writer :shared_folder_gid
+      attr_accessor :system
+
+      # Represents a SubVM. This class is only used here in the VMs
+      # hash.
+      class SubVM
+        include Util::StackedProcRunner
+
+        def options
+          @options ||= {}
+        end
+      end
+
+      def initialize
+        @forwarded_ports = {}
+        @shared_folders = {}
+        @provisioner = nil
+        @network_options = []
+      end
+
+      def forward_port(name, guestport, hostport, options=nil)
+        options = {
+          :guestport  => guestport,
+          :hostport   => hostport,
+          :protocol   => "TCP",
+          :adapter    => 0,
+          :auto       => false
+        }.merge(options || {})
+
+        forwarded_ports[name] = options
+      end
+
+      def share_folder(name, guestpath, hostpath, opts=nil)
+        @shared_folders[name] = {
+          :guestpath => guestpath,
+          :hostpath => hostpath
+        }.merge(opts || {})
+      end
+
+      def network(ip, options=nil)
+        options = {
+          :ip => ip,
+          :netmask => "255.255.255.0",
+          :adapter => 1,
+          :name => nil
+        }.merge(options || {})
+
+        @network_options[options[:adapter]] = options
+      end
+
+      def shared_folder_uid
+        @shared_folder_uid || env.config.ssh.username
+      end
+
+      def shared_folder_gid
+        @shared_folder_gid || env.config.ssh.username
+      end
+
+      def customize(&block)
+        push_proc(&block)
+      end
+
+      def has_multi_vms?
+        !defined_vms.empty?
+      end
+
+      def defined_vms
+        @defined_vms ||= {}
+      end
+
+      def define(name, options=nil, &block)
+        options ||= {}
+        defined_vms[name.to_sym] ||= SubVM.new
+        defined_vms[name.to_sym].options.merge!(options)
+        defined_vms[name.to_sym].push_proc(&block)
+      end
+
+      def validate(errors)
+        shared_folders.each do |name, options|
+          if !File.directory?(File.expand_path(options[:hostpath].to_s, env.root_path))
+            errors.add(I18n.t("vagrant.config.vm.shared_folder_hostpath_missing",
+                       :name => name,
+                       :path => options[:hostpath]))
+          end
+        end
+
+        errors.add(I18n.t("vagrant.config.vm.boot_mode_invalid")) if ![:vrdp, :gui].include?(boot_mode.to_sym)
+      end
+    end
+  end
+end

data/lib/vagrant/data_store.rb

@@ -0,0 +1,68 @@
+module Vagrant
+  # The Vagrant data store is a key-value store which is persisted
+  # as JSON in a local file which is specified in the initializer.
+  # The data store itself is accessed via typical hash accessors: `[]`
+  # and `[]=`. If a key is set to `nil`, then it is removed from the
+  # datastore. The data store is only updated on disk when {#commit}
+  # is called on the data store itself.
+  #
+  # The data store is a hash with indifferent access, meaning that
+  # while all keys are persisted as strings in the JSON, you can access
+  # them back as either symbols or strings. Note that this is only true
+  # for the top-level data store. As soon as you set a hash inside the
+  # data store, unless you explicitly use a {Util::HashWithIndifferentAccess},
+  # it will be a regular hash.
+  class DataStore < Util::HashWithIndifferentAccess
+    attr_reader :file_path
+
+    def initialize(file_path)
+      @file_path = file_path
+      return if !file_path
+
+      File.open(file_path, "r") do |f|
+        merge!(JSON.parse(f.read))
+      end
+    rescue Errno::ENOENT
+      clear
+    end
+
+    # Commits any changes to the data to disk. Even if the data
+    # hasn't changed, it will be reserialized and written to disk.
+    def commit
+      return if !file_path
+
+      clean_nil_and_empties
+
+      if empty?
+        # Delete the file since an empty data store is not useful
+        File.delete(file_path) if File.file?(file_path)
+      else
+        File.open(file_path, "w") { |f| f.write(to_json) }
+      end
+    end
+
+    protected
+
+    # Removes the "nil" and "empty?" values from the hash (children
+    # included) so that the final output JSON is cleaner.
+    def clean_nil_and_empties(hash=self)
+      # Clean depth first
+      hash.each do |k, v|
+        clean_nil_and_empties(v) if v.is_a?(Hash)
+      end
+
+      # Clean ourselves, knowing that any children have already been
+      # cleaned up
+      bad_keys = hash.inject([]) do |acc, data|
+        k,v = data
+        acc.push(k) if v.nil?
+        acc.push(k) if v.respond_to?(:empty?) && v.empty?
+        acc
+      end
+
+      bad_keys.each do |key|
+        hash.delete(key)
+      end
+    end
+  end
+end

data/lib/vagrant/downloaders/file.rb

@@ -1,3 +1,5 @@
+require 'fileutils'
+
 module Vagrant
   module Downloaders
     # "Downloads" a file to a temporary file. Basically, this downloader
@@ -8,9 +10,7 @@ module Vagrant
       end
 
       def prepare(source_url)
-        if !::File.file?(source_url)
-          return env.error!(:downloader_file_doesnt_exist, :source_url => source_url)
-        end
+        raise Errors::DownloaderFileDoesntExist.new if !::File.file?(source_url)
       end
 
       def download!(source_url, destination_file)

data/lib/vagrant/downloaders/http.rb

@@ -15,8 +15,10 @@ module Vagrant
       end
 
       def download!(source_url, destination_file)
+        proxy_uri = URI.parse(ENV["http_proxy"] || "")
         uri = URI.parse(source_url)
-        http = Net::HTTP.new(uri.host, uri.port)
+        http = Net::HTTP.new(uri.host, uri.port, proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+
         if uri.scheme == "https"
           http.use_ssl = true
           http.verify_mode = OpenSSL::SSL::VERIFY_NONE
@@ -36,7 +38,7 @@ module Vagrant
               # Progress reporting is limited to every 25 segments just so
               # we're not constantly updating
               if segment_count % 25 == 0
-                env.logger.report_progress(progress, total)
+                env.ui.report_progress(progress, total)
                 segment_count = 0
               end
 
@@ -45,10 +47,8 @@ module Vagrant
             end
           end
         end
-
-        env.logger.clear_progress
       rescue SocketError
-        env.error!(:box_download_http_socket_error, :box_url => source_url)
+        raise Errors::DownloaderHTTPSocketError.new
       end
     end
   end

data/lib/vagrant/environment.rb

@@ -1,109 +1,143 @@
+require 'pathname'
+require 'fileutils'
+
 module Vagrant
-  # Represents a single Vagrant environment. This class is responsible
-  # for loading all of the Vagrantfile's for the given environment and
-  # storing references to the various instances.
+  # Represents a single Vagrant environment. A "Vagrant environment" is
+  # 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
     ROOTFILE_NAME = "Vagrantfile"
-    HOME_SUBDIRS = ["tmp", "boxes"]
+    HOME_SUBDIRS = ["tmp", "boxes", "logs"]
     DEFAULT_VM = :default
 
-    include Util
+    # Parent environment (in the case of multi-VMs)
+    attr_reader :parent
 
-    attr_reader :parent     # Parent environment (in the case of multi-VMs)
-    attr_reader :vm_name    # The name of the VM (internal name) which this environment represents
+    # The `cwd` that this environment represents
+    attr_reader :cwd
 
-    attr_accessor :cwd
-    attr_reader :root_path
-    attr_reader :config
-    attr_reader :host
-    attr_reader :box
+    # The single VM that this environment represents, in the case of
+    # multi-VM.
     attr_accessor :vm
-    attr_reader :vms
-    attr_reader :active_list
-    attr_reader :commands
-    attr_reader :logger
-    attr_reader :actions
+
+    # The {UI} object to communicate with the outside world.
+    attr_writer :ui
 
     #---------------------------------------------------------------
     # Class Methods
     #---------------------------------------------------------------
     class << self
-      # Loads and returns an environment given a specific working
-      # directory. If a working directory is not given, it will default
-      # to the pwd.
-      def load!(cwd=nil)
-        Environment.new(:cwd => cwd).load!
-      end
-
       # Verifies that VirtualBox is installed and that the version of
-      # VirtualBox installed is high enough. Also verifies that the
-      # configuration path is properly set.
+      # VirtualBox installed is high enough.
       def check_virtualbox!
         version = VirtualBox.version
-        if version.nil?
-          error_and_exit(:virtualbox_not_detected)
-        elsif version.to_f < 3.2
-          error_and_exit(:virtualbox_invalid_version, :version => version.to_s)
-        elsif version.to_s.downcase.include?("ose")
-          error_and_exit(:virtualbox_invalid_ose, :version => version.to_s)
-        end
+        raise Errors::VirtualBoxNotDetected.new if version.nil?
+        raise Errors::VirtualBoxInvalidVersion.new(:version => version.to_s) if version.to_f < 3.2
+        raise Errors::VirtualBoxInvalidOSE.new(:version => version.to_s) if version.to_s.downcase.include?("ose")
       end
     end
 
+    # Initializes a new environment with the given options. The options
+    # is a hash where the main available key is `cwd`, which defines where
+    # the environment represents. There are other options available but
+    # they shouldn't be used in general. If `cwd` is nil, then it defaults
+    # to the `Dir.pwd` (which is the cwd of the executing process).
     def initialize(opts=nil)
-      defaults = {
+      opts = {
         :parent => nil,
-        :vm_name => nil,
         :vm => nil,
-        :cwd => nil
-      }
+        :cwd => nil,
+      }.merge(opts || {})
 
-      opts = defaults.merge(opts || {})
+      opts[:cwd] ||= Dir.pwd
+      opts[:cwd] = Pathname.new(opts[:cwd])
 
-      defaults.each do |key, value|
+      opts.each do |key, value|
         instance_variable_set("@#{key}".to_sym, opts[key])
       end
+
+      @loaded = false
     end
 
     #---------------------------------------------------------------
     # Helpers
     #---------------------------------------------------------------
 
-    # Specifies the "current working directory" for this environment.
-    # This is vital in determining the root path and therefore the
-    # dotfile, rootpath vagrantfile, etc. This defaults to the
-    # actual cwd (`Dir.pwd`).
-    def cwd
-      @cwd || Dir.pwd
-    end
-
     # The path to the `dotfile`, which contains the persisted UUID of
     # the VM if it exists.
+    #
+    # @return [Pathname]
     def dotfile_path
-      root_path ? File.join(root_path, config.vagrant.dotfile_name) : nil
+      root_path.join(config.vagrant.dotfile_name) rescue nil
     end
 
-    # The path to the home directory, which is usually in `~/.vagrant/~
+    # The path to the home directory, expanded relative to the root path,
+    # and converted into a Pathname object.
+    #
+    # @return [Pathname]
     def home_path
-      config ? config.vagrant.home : nil
+      @_home_path ||= Pathname.new(File.expand_path(config.vagrant.home, root_path))
     end
 
     # The path to the Vagrant tmp directory
+    #
+    # @return [Pathname]
     def tmp_path
-      File.join(home_path, "tmp")
+      home_path.join("tmp")
     end
 
     # The path to the Vagrant boxes directory
+    #
+    # @return [Pathname]
     def boxes_path
-      File.join(home_path, "boxes")
+      home_path.join("boxes")
+    end
+
+    # Path to the Vagrant logs directory
+    #
+    # @return [Pathname]
+    def log_path
+      home_path.join("logs")
+    end
+
+    # Returns the name of the resource which this environment represents.
+    # The resource is the VM name if there is a VM it represents, otherwise
+    # it defaults to "vagrant"
+    #
+    # @return [String]
+    def resource
+      vm.name rescue "vagrant"
+    end
+
+    # Returns the collection of boxes for the environment.
+    #
+    # @return [BoxCollection]
+    def boxes
+      return parent.boxes if parent
+      @_boxes ||= BoxCollection.new(self)
+    end
+
+    # Returns the box that this environment represents.
+    #
+    # @return [Box]
+    def box
+      boxes.find(config.vm.box)
     end
 
     # Returns the VMs associated with this environment.
+    #
+    # @return [Array<VM>]
     def vms
-      @vms ||= {}
+      return parent.vms if parent
+      load! if !loaded?
+      @vms ||= load_vms!
     end
 
-    # Returns the primray VM associated with this environment
+    # 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.
+    #
+    # @return [VM]
     def primary_vm
       return vms.values.first if !multivm?
       return parent.primary_vm if parent
@@ -118,6 +152,8 @@ module Vagrant
     # Returns a boolean whether this environment represents a multi-VM
     # environment or not. This will work even when called on child
     # environments.
+    #
+    # @return [Bool]
     def multivm?
       if parent
         parent.multivm?
@@ -126,237 +162,204 @@ module Vagrant
       end
     end
 
+    # Makes a call to the CLI with the given arguments as if they
+    # came from the real command line (sometimes they do!). An example:
+    #
+    #     env.cli("package", "--vagrantfile", "Vagrantfile")
+    #
+    def cli(*args)
+      CLI.start(args.flatten, :env => self)
+    end
+
+    # Returns the {UI} for the environment, which is responsible
+    # for talking with the outside world.
+    #
+    # @return [UI]
+    def ui
+      @ui ||= if parent
+        result = parent.ui.clone
+        result.env = self
+        result
+      else
+        UI.new(self)
+      end
+    end
+
+    # Returns the host object associated with this environment.
+    #
+    # @return [Hosts::Base]
+    def host
+      @host ||= Hosts::Base.load(self, config.vagrant.host)
+    end
+
+    # Returns the {Action} class for this environment which allows actions
+    # to be executed (middleware chains) in the context of this environment.
+    #
+    # @return [Action]
+    def actions
+      @actions ||= Action.new(self)
+    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
+      return parent.global_data if parent
+      @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
+      return parent.local_data if parent
+      @local_data ||= DataStore.new(dotfile_path)
+    end
+
+    # Accesses the logger for Vagrant. This logger is a _detailed_
+    # logger which should be used to log internals only. For outward
+    # facing information, use {#ui}.
+    #
+    # @return [Logger]
+    def logger
+      return parent.logger if parent
+      @logger ||= Util::ResourceLogger.new(resource, self)
+    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.
+    #
+    # @return [String]
+    def root_path
+      return @root_path if defined?(@root_path)
+
+      root_finder = lambda do |path|
+        return path if File.exist?(File.join(path.to_s, ROOTFILE_NAME))
+        return nil if path.root?
+        root_finder.call(path.parent)
+      end
+
+      @root_path = root_finder.call(cwd)
+    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::Top]
+    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!
-      load_logger!
-      load_root_path!
-      load_config!
-      load_home_directory!
-      load_host!
-      load_box!
-      load_config!
-      self.class.check_virtualbox!
-      load_vm!
-      load_active_list!
-      load_commands!
-      load_actions!
-      self
-    end
-
-    # Loads the root path of this environment, given the starting
-    # directory (the "cwd" of this environment for lack of better words).
-    # This method allows an environment in `/foo` to be detected from
-    # `/foo/bar` (similar to how git works in subdirectories)
-    def load_root_path!(path=nil)
-      path = Pathname.new(File.expand_path(path || cwd))
-
-      # Stop if we're at the root.
-      return false if path.root?
-
-      file = "#{path}/#{ROOTFILE_NAME}"
-      if File.exist?(file)
-        @root_path = path.to_s
-        return true
+      if !loaded?
+        @loaded = true
+        self.class.check_virtualbox!
+        load_config!
+        actions.run(:environment_load)
       end
 
-      load_root_path!(path.parent)
+      self
     end
 
-    # Loads this environment's configuration and stores it in the {config}
+    # 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!
-      # Prepare load paths for config files and append to config queue
-      config_queue = [File.join(PROJECT_ROOT, "config", "default.rb")]
-      config_queue << File.join(box.directory, ROOTFILE_NAME) if box
-      config_queue << File.join(home_path, ROOTFILE_NAME) if home_path
-      config_queue << File.join(root_path, ROOTFILE_NAME) if root_path
-
-      # If this environment represents some VM in a multi-VM environment,
-      # we push that VM's configuration onto the config_queue.
-      if vm_name
-        subvm = parent.config.vm.defined_vms[vm_name]
-        config_queue << subvm.proc_stack if subvm
+      first_run = @config.nil?
+
+      # First load the initial, non config-dependent Vagrantfiles
+      loader = Config.new(self)
+      loader.queue << File.expand_path("config/default.rb", Vagrant.source_root)
+      loader.queue << File.join(box.directory, ROOTFILE_NAME) if !first_run && box
+      loader.queue << File.join(home_path, ROOTFILE_NAME) if !first_run && home_path
+      loader.queue << File.join(root_path, ROOTFILE_NAME) if root_path
+
+      # If this environment is representing a sub-VM, then we push that
+      # proc on as the last configuration.
+      if !first_run && vm
+        subvm = parent.config.vm.defined_vms[vm.name]
+        loader.queue << subvm.proc_stack if subvm
       end
 
-      # Flatten the config queue so any nested procs are flattened
-      config_queue.flatten!
-
-      # Clear out the old data
-      Config.reset!(self)
-
-      # Load each of the config files in order
-      config_queue.each do |item|
-        if item.is_a?(String) && File.exist?(item)
-          load item
-          next
-        end
-
-        if item.is_a?(Proc)
-          # Just push the proc straight onto the config runnable stack
-          Config.run(&item)
-        end
-      end
-
-      # Execute the configuration stack and store the result
-      @config = Config.execute!
+      # Execute the configuration stack and store the result as the final
+      # value in the config ivar.
+      @config = loader.load!
 
       # (re)load the logger
-      load_logger!
-    end
+      @logger = nil
 
-    # Loads the logger for this environment. This is called by
-    # {#load_config!} so that the logger is only loaded after
-    # configuration information is available. The logger is also
-    # loaded early on in the load chain process so that the various
-    # references to logger won't throw nil exceptions, but by default
-    # the logger will just send the log data to a black hole.
-    def load_logger!
-      resource = vm_name || "vagrant"
-      @logger = Util::ResourceLogger.new(resource, self)
+      if first_run
+        # After the first run we want to load the configuration again since
+        # it can change due to box Vagrantfiles and home directory Vagrantfiles
+        load_home_directory!
+        load_config!
+      end
     end
 
     # Loads the home directory path and creates the necessary subdirectories
     # within the home directory if they're not already created.
     def load_home_directory!
       # Setup the array of necessary home directories
-      dirs = HOME_SUBDIRS.collect { |subdir| File.join(home_path, subdir) }
-      dirs.unshift(home_path)
+      dirs = [home_path]
+      dirs += HOME_SUBDIRS.collect { |subdir| home_path.join(subdir) }
 
       # Go through each required directory, creating it if it doesn't exist
       dirs.each do |dir|
         next if File.directory?(dir)
 
-        logger.info "Creating home directory since it doesn't exist: #{dir}"
+        ui.info I18n.t("vagrant.general.creating_home_dir", :directory => dir)
         FileUtils.mkdir_p(dir)
       end
     end
 
-    # Loads the host class for this environment.
-    def load_host!
-      @host = Hosts::Base.load(self, config.vagrant.host)
-    end
-
-    # Loads the specified box for this environment.
-    def load_box!
-      return unless root_path
-
-      @box = Box.find(self, config.vm.box) if config.vm.box
-    end
-
     # Loads the persisted VM (if it exists) for this environment.
-    def load_vm!
-      # This environment represents a single sub VM. The VM is then
-      # probably (read: should be) set on the VM attribute, so we do
-      # nothing.
-      return if vm_name
-
-      # First load the defaults (blank, noncreated VMs)
-      load_blank_vms!
-
-      # If we have no dotfile, then return
-      return if !dotfile_path || !File.file?(dotfile_path)
-
-      # Open and parse the dotfile
-      File.open(dotfile_path) do |f|
-        data = { DEFAULT_VM => f.read }
-
-        begin
-          data = JSON.parse(data[DEFAULT_VM])
-        rescue JSON::ParserError
-          # Most likely an older (<= 0.3.x) dotfile. Try to load it
-          # as the :__vagrant VM.
-        end
-
-        data.each do |key, value|
-          key = key.to_sym
-          vms[key] = Vagrant::VM.find(value, self, key)
-        end
-      end
-    rescue Errno::ENOENT
-      # Just rescue it.
-    end
-
-    # Loads blank VMs into the `vms` attribute.
-    def load_blank_vms!
-      # Clear existing vms
-      vms.clear
-
-      # Load up the blank VMs
-      defined_vms = config.vm.defined_vms.keys
-      defined_vms = [DEFAULT_VM] if defined_vms.empty?
-
-      defined_vms.each do |name|
-        vms[name] = Vagrant::VM.new(:vm_name => name, :env => self)
-      end
-    end
-
-    # Loads the activelist for this environment
-    def load_active_list!
-      @active_list = ActiveList.new(self)
-    end
-
-    # Loads the instance of {Command} for this environment. This allows
-    # users of the instance to run commands such as "up" "down" etc. in
-    # the context of this environment.
-    def load_commands!
-      @commands = Command.new(self)
-    end
-
-    # Loads the instance of {Action} for this environment. This allows
-    # users of the instance to run action sequences in the context of
-    # this environment.
-    def load_actions!
-      @actions = Action.new(self)
-    end
-
-    #---------------------------------------------------------------
-    # Methods to manage VM
-    #---------------------------------------------------------------
-
-    # Persists this environment's VM to the dotfile so it can be
-    # re-loaded at a later time.
-    def update_dotfile
-      return parent.update_dotfile if parent
+    def load_vms!
+      result = {}
 
-      # Generate and save the persisted VM info
-      data = vms.inject({}) do |acc, data|
-        key, value = data
-        acc[key] = value.uuid if value.created?
-        acc
+      # Load the VM UUIDs from the local data store
+      (local_data[:active] || {}).each do |name, uuid|
+        result[name.to_sym] = Vagrant::VM.find(uuid, self, name.to_sym)
       end
 
-      if data.empty?
-        File.delete(dotfile_path) if File.exist?(dotfile_path)
-      else
-        File.open(dotfile_path, 'w+') do |f|
-          f.write(data.to_json)
-        end
+      # For any VMs which aren't created, create a blank VM instance for
+      # them
+      all_keys = config.vm.defined_vms.keys
+      all_keys = [DEFAULT_VM] if all_keys.empty?
+      all_keys.each do |name|
+        result[name] = Vagrant::VM.new(:name => name, :env => self) if !result.has_key?(name)
       end
 
-      # Also add to the global store
-      # active_list.add(vm)
-    end
-
-    #---------------------------------------------------------------
-    # Methods to check for properties and error
-    #---------------------------------------------------------------
-
-    def require_root_path
-      error_and_exit(:rootfile_not_found) if !root_path
-    end
-
-    def require_persisted_vm
-      require_root_path
-
-      error_and_exit(:environment_not_created) if !vm
+      result
     end
   end
 end