vagrantup 1.0.7 → 1.1.0

data/lib/vagrant/config/loader.rb

@@ -12,15 +12,21 @@ module Vagrant
     # set later always overrides those set earlier; this is how
     # configuration "scoping" is implemented.
     class Loader
-      # This is an array of symbols specifying the order in which
-      # configuration is loaded. For examples, see the class documentation.
-      attr_accessor :load_order
-
-      def initialize
-        @logger  = Log4r::Logger.new("vagrant::config::loader")
-        @sources = {}
-        @proc_cache = {}
-        @config_cache = {}
+      # Initializes a configuration loader.
+      #
+      # @param [Registry] versions A registry of the available versions and
+      #   their associated loaders.
+      # @param [Array] version_order An array of the order of the versions
+      #   in the registry. This is used to determine if upgrades are
+      #   necessary. Additionally, the last version in this order is always
+      #   considered the "current" version.
+      def initialize(versions, version_order)
+        @logger        = Log4r::Logger.new("vagrant::config::loader")
+        @config_cache  = {}
+        @proc_cache    = {}
+        @sources       = {}
+        @versions      = versions
+        @version_order = version_order
       end
 
       # Set the configuration data for the given name.
@@ -35,7 +41,7 @@ module Vagrant
       # `set` multiple times with the same name will override any previously
       # set values. In this way, the last set data for a given name wins.
       def set(name, sources)
-        @logger.debug("Set #{name.inspect} = #{sources.inspect}")
+        @logger.info("Set #{name.inspect} = #{sources.inspect}")
 
         # Sources should be an array
         sources = [sources] if !sources.kind_of?(Array)
@@ -59,40 +65,98 @@ module Vagrant
         @sources[name] = procs
       end
 
-      # This loads the configured sources in the configured order and returns
+      # This loads the configuration sources in the given order and returns
       # an actual configuration object that is ready to be used.
-      def load
-        @logger.debug("Loading configuration in order: #{@load_order.inspect}")
+      #
+      # @param [Array<Symbol>] order The order of configuration to load.
+      # @return [Object] The configuration object. This is different for
+      #   each configuration version.
+      def load(order)
+        @logger.info("Loading configuration in order: #{order.inspect}")
 
-        unknown_sources = @sources.keys - @load_order
+        unknown_sources = @sources.keys - order
         if !unknown_sources.empty?
           # TODO: Raise exception here perhaps.
           @logger.error("Unknown config sources: #{unknown_sources.inspect}")
         end
 
-        # Create the top-level configuration which will hold all the config.
-        result = Top.new
+        # Get the current version config class to use
+        current_version      = @version_order.last
+        current_config_klass = @versions.get(current_version)
+
+        # This will hold our result
+        result = current_config_klass.init
 
-        @load_order.each do |key|
+        # Keep track of the warnings and errors that may come from
+        # upgrading the Vagrantfiles
+        warnings = []
+        errors   = []
+
+        order.each do |key|
           next if !@sources.has_key?(key)
 
-          @sources[key].each do |proc|
+          @sources[key].each do |version, proc|
             if !@config_cache.has_key?(proc)
               @logger.debug("Loading from: #{key} (evaluating)")
-              current = Top.new
-              proc.call(current)
-              @config_cache[proc] = current
+
+              # Get the proper version loader for this version and load
+              version_loader = @versions.get(version)
+              version_config = version_loader.load(proc)
+
+              # Store the errors/warnings associated with loading this
+              # configuration. We'll store these for later.
+              version_warnings = []
+              version_errors   = []
+
+              # If this version is not the current version, then we need
+              # to upgrade to the latest version.
+              if version != current_version
+                @logger.debug("Upgrading config from version #{version} to #{current_version}")
+                version_index = @version_order.index(version)
+                current_index = @version_order.index(current_version)
+
+                (version_index + 1).upto(current_index) do |index|
+                  next_version = @version_order[index]
+                  @logger.debug("Upgrading config to version #{next_version}")
+
+                  # Get the loader of this version and ask it to upgrade
+                  loader = @versions.get(next_version)
+                  upgrade_result = loader.upgrade(version_config)
+
+                  this_warnings = upgrade_result[1]
+                  this_errors   = upgrade_result[2]
+                  @logger.debug("Upgraded to version #{next_version} with " +
+                                "#{this_warnings.length} warnings and " +
+                                "#{this_errors.length} errors")
+
+                  # Append loading this to the version warnings and errors
+                  version_warnings += this_warnings
+                  version_errors   += this_errors
+
+                  # Store the new upgraded version
+                  version_config = upgrade_result[0]
+                end
+              end
+
+              # Cache the loaded configuration along with any warnings
+              # or errors so that they can be retrieved later.
+              @config_cache[proc] = [version_config, version_warnings, version_errors]
             else
               @logger.debug("Loading from: #{key} (cache)")
             end
 
-            # Merge in the results of this proc's configuration
-            result = result.merge(@config_cache[proc])
+            # Merge the configurations
+            cache_data = @config_cache[proc]
+            result = current_config_klass.merge(result, cache_data[0])
+
+            # Append the total warnings/errors
+            warnings += cache_data[1]
+            errors   += cache_data[2]
           end
         end
 
-        @logger.debug("Configuration loaded successfully")
-        result
+        @logger.debug("Configuration loaded successfully, finalizing and returning")
+        [current_config_klass.finalize(result), warnings, errors]
       end
 
       protected
@@ -102,25 +166,56 @@ module Vagrant
       # the configuration object and are expected to mutate this
       # configuration object.
       def procs_for_source(source)
-        return [source] if source.is_a?(Proc)
-
-        # Assume all string sources are actually pathnames
-        source = Pathname.new(source) if source.is_a?(String)
+        # Convert all pathnames to strings so we just have their path
+        source = source.to_s if source.is_a?(Pathname)
+
+        if source.is_a?(Array)
+          # An array must be formatted as [version, proc], so verify
+          # that and then return it
+          raise ArgumentError, "String source must have format [version, proc]" if source.length != 2
+
+          # Return it as an array since we're expected to return an array
+          # of [version, proc] pairs, but an array source only has one.
+          return [source]
+        elsif source.is_a?(String)
+          # Strings are considered paths, so load them
+          return procs_for_path(source)
+        else
+          raise ArgumentError, "Unknown configuration source: #{source.inspect}"
+        end
+      end
 
-        if source.is_a?(Pathname)
-          @logger.debug("Load procs for pathname: #{source.inspect}")
+      # This returns an array of `Proc` objects for the given path source.
+      #
+      # @param [String] path Path to the file which contains the proper
+      #   `Vagrant.configure` calls.
+      # @return [Array<Proc>]
+      def procs_for_path(path)
+        @logger.debug("Load procs for pathname: #{path}")
 
+        return Config.capture_configures do
           begin
-            return Config.capture_configures do
-              Kernel.load source
-            end
+            Kernel.load path
           rescue SyntaxError => e
             # Report syntax errors in a nice way.
             raise Errors::VagrantfileSyntaxError, :file => e.message
+          rescue SystemExit
+            # Continue raising that exception...
+            raise
+          rescue Vagrant::Errors::VagrantError
+            # Continue raising known Vagrant errors since they already
+            # contain well worded error messages and context.
+            raise
+          rescue Exception => e
+            @logger.error("Vagrantfile load error: #{e.message}")
+            @logger.error(e.backtrace.join("\n"))
+
+            # Report the generic exception
+            raise Errors::VagrantfileLoadError,
+              :path => path,
+              :message => e.message
           end
         end
-
-        raise Exception, "Unknown configuration source: #{source.inspect}"
       end
     end
   end

data/lib/vagrant/config/v1.rb

@@ -0,0 +1,9 @@
+module Vagrant
+  module Config
+    module V1
+      autoload :DummyConfig, "vagrant/config/v1/dummy_config"
+      autoload :Loader, "vagrant/config/v1/loader"
+      autoload :Root,   "vagrant/config/v1/root"
+    end
+  end
+end

data/lib/vagrant/config/v1/dummy_config.rb

@@ -0,0 +1,13 @@
+module Vagrant
+  module Config
+    module V1
+      # This is a configuration object that can have anything done
+      # to it. Anything, and it just appears to keep working.
+      class DummyConfig
+        def method_missing(name, *args, &block)
+          DummyConfig.new
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/v1/loader.rb

@@ -0,0 +1,105 @@
+require "vagrant/config/v1/root"
+
+module Vagrant
+  module Config
+    module V1
+      # This is the loader that handles configuration loading for V1
+      # configurations.
+      class Loader < VersionBase
+        # Returns a bare empty configuration object.
+        #
+        # @return [V1::Root]
+        def self.init
+          new_root_object
+        end
+
+        # Finalizes the configuration by making sure there is at least
+        # one VM defined in it.
+        def self.finalize(config)
+          # Call the `#finalize` method on each of the configuration keys.
+          # They're expected to modify themselves in our case.
+          config.finalize!
+
+          # Return the object
+          config
+        end
+
+        # Loads the configuration for the given proc and returns a configuration
+        # object.
+        #
+        # @param [Proc] config_proc
+        # @return [Object]
+        def self.load(config_proc)
+          # Create a root configuration object
+          root = new_root_object
+
+          # Call the proc with the root
+          config_proc.call(root)
+
+          # Return the root object, which doubles as the configuration object
+          # we actually use for accessing as well.
+          root
+        end
+
+        # Merges two configuration objects.
+        #
+        # @param [V1::Root] old The older root config.
+        # @param [V1::Root] new The newer root config.
+        # @return [V1::Root]
+        def self.merge(old, new)
+          # Grab the internal states, we use these heavily throughout the process
+          old_state = old.__internal_state
+          new_state = new.__internal_state
+
+          # The config map for the new object is the old one merged with the
+          # new one.
+          config_map = old_state["config_map"].merge(new_state["config_map"])
+
+          # Merge the keys.
+          old_keys = old_state["keys"]
+          new_keys = new_state["keys"]
+          keys     = {}
+          old_keys.each do |key, old_value|
+            if new_keys.has_key?(key)
+              # We need to do a merge, which we expect to be available
+              # on the config class itself.
+              keys[key] = old_value.merge(new_keys[key])
+            else
+              # We just take the old value, but dup it so that we can modify.
+              keys[key] = old_value.dup
+            end
+          end
+
+          new_keys.each do |key, new_value|
+            # Add in the keys that the new class has that we haven't merged.
+            if !keys.has_key?(key)
+              keys[key] = new_value.dup
+            end
+          end
+
+          # Return the final root object
+          V1::Root.new(config_map, keys)
+        end
+
+        protected
+
+        def self.new_root_object
+          # Get all the registered configuration objects and use them. If
+          # we're currently on version 1, then we load all the config objects,
+          # otherwise we load only the upgrade safe ones, since we're
+          # obviously being loaded for an upgrade.
+          config_map = nil
+          plugin_manager = Vagrant.plugin("1").manager
+          if Config::CURRENT_VERSION == "1"
+            config_map = plugin_manager.config
+          else
+            config_map = plugin_manager.config_upgrade_safe
+          end
+
+          # Create the configuration root object
+          V1::Root.new(config_map)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require "set"
+
+module Vagrant
+  module Config
+    module V1
+      # 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
+
+        # 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
+      end
+    end
+  end
+end

data/lib/vagrant/config/v2.rb

@@ -0,0 +1,9 @@
+module Vagrant
+  module Config
+    module V2
+      autoload :DummyConfig, "vagrant/config/v2/dummy_config"
+      autoload :Loader, "vagrant/config/v2/loader"
+      autoload :Root,   "vagrant/config/v2/root"
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Vagrant
+  module Config
+    module V2
+      # This is a configuration object that can have anything done
+      # to it. Anything, and it just appears to keep working.
+      class DummyConfig
+        def method_missing(name, *args, &block)
+          DummyConfig.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require "vagrant/config/v2/root"
+
+module Vagrant
+  module Config
+    module V2
+      # This is the loader that handles configuration loading for V2
+      # configurations.
+      class Loader < VersionBase
+        # Returns a bare empty configuration object.
+        #
+        # @return [V2::Root]
+        def self.init
+          new_root_object
+        end
+
+        # Finalizes the configuration by making sure there is at least
+        # one VM defined in it.
+        def self.finalize(config)
+          # Call the `#finalize` method on each of the configuration keys.
+          # They're expected to modify themselves in our case.
+          config.finalize!
+
+          # Return the object
+          config
+        end
+
+        # Loads the configuration for the given proc and returns a configuration
+        # object.
+        #
+        # @param [Proc] config_proc
+        # @return [Object]
+        def self.load(config_proc)
+          # Create a root configuration object
+          root = new_root_object
+
+          # Call the proc with the root
+          config_proc.call(root)
+
+          # Return the root object, which doubles as the configuration object
+          # we actually use for accessing as well.
+          root
+        end
+
+        # Merges two configuration objects.
+        #
+        # @param [V2::Root] old The older root config.
+        # @param [V2::Root] new The newer root config.
+        # @return [V2::Root]
+        def self.merge(old, new)
+          # Grab the internal states, we use these heavily throughout the process
+          old_state = old.__internal_state
+          new_state = new.__internal_state
+
+          # The config map for the new object is the old one merged with the
+          # new one.
+          config_map = old_state["config_map"].merge(new_state["config_map"])
+
+          # Merge the keys.
+          old_keys = old_state["keys"]
+          new_keys = new_state["keys"]
+          keys     = {}
+          old_keys.each do |key, old_value|
+            if new_keys.has_key?(key)
+              # We need to do a merge, which we expect to be available
+              # on the config class itself.
+              keys[key] = old_value.merge(new_keys[key])
+            else
+              # We just take the old value, but dup it so that we can modify.
+              keys[key] = old_value.dup
+            end
+          end
+
+          new_keys.each do |key, new_value|
+            # Add in the keys that the new class has that we haven't merged.
+            if !keys.has_key?(key)
+              keys[key] = new_value.dup
+            end
+          end
+
+          # Merge the missing keys
+          new_missing_key_calls =
+            old_state["missing_key_calls"] + new_state["missing_key_calls"]
+
+          # Return the final root object
+          V2::Root.new(config_map).tap do |result|
+            result.__set_internal_state({
+              "config_map"        => config_map,
+              "keys"              => keys,
+              "missing_key_calls" => new_missing_key_calls
+            })
+          end
+        end
+
+        # Upgrade a V1 configuration to a V2 configuration. We do this by
+        # creating a V2 configuration, and calling "upgrade" on each of the
+        # V1 configurations, expecting them to set the right settings on the
+        # new root.
+        #
+        # @param [V1::Root] old
+        # @return [Array] A 3-tuple result.
+        def self.upgrade(old)
+          # Get a new root
+          root = new_root_object
+
+          # Store the warnings/errors
+          warnings = []
+          errors   = []
+
+          # Go through the old keys and upgrade them if they can be
+          old.__internal_state["keys"].each do |_, old_value|
+            if old_value.respond_to?(:upgrade)
+              result = old_value.upgrade(root)
+
+              # Sanity check to guard against random return values
+              if result.is_a?(Array)
+                warnings += result[0]
+                errors   += result[1]
+              end
+            end
+          end
+
+          old.__internal_state["missing_key_calls"].to_a.sort.each do |key|
+            warnings << I18n.t("vagrant.config.loader.bad_v1_key", :key => key)
+          end
+
+          [root, warnings, errors]
+        end
+
+        protected
+
+        def self.new_root_object
+          # Get all the registered plugins for V2
+          config_map = Vagrant.plugin("2").manager.config
+
+          # Create the configuration root object
+          V2::Root.new(config_map)
+        end
+      end
+    end
+  end
+end