tnargav 1.3.5 → 1.3.6

data/lib/vagrant/config.rb

@@ -0,0 +1,61 @@
+require "vagrant/registry"
+
+module Vagrant
+  module Config
+    autoload :Loader,        'vagrant/config/loader'
+    autoload :VersionBase,   'vagrant/config/version_base'
+
+    autoload :V1,            'vagrant/config/v1'
+    autoload :V2,            'vagrant/config/v2'
+
+    # This is a mutex used to guarantee that only one thread can load
+    # procs at any given time.
+    CONFIGURE_MUTEX = Mutex.new
+
+    # This is the registry which keeps track of what configuration
+    # versions are available, mapped by the version string used in
+    # `Vagrant.configure` calls.
+    VERSIONS = Registry.new
+    VERSIONS.register("1") { V1::Loader }
+    VERSIONS.register("2") { V2::Loader }
+
+    # This is the order of versions. This is used by the loader to figure out
+    # how to "upgrade" versions up to the desired (current) version. The
+    # current version is always considered to be the last version in this
+    # list.
+    VERSIONS_ORDER = ["1", "2"]
+    CURRENT_VERSION = VERSIONS_ORDER.last
+
+    # This is the method which is called by all Vagrantfiles to configure Vagrant.
+    # This method expects a block which accepts a single argument representing
+    # an instance of the {Config::Top} class.
+    #
+    # Note that the block is not run immediately. Instead, it's proc is stored
+    # away for execution later.
+    def self.run(version="1", &block)
+      # Store it for later
+      @last_procs ||= []
+      @last_procs << [version, block]
+    end
+
+    # This is a method which will yield to a block and will capture all
+    # ``Vagrant.configure`` calls, returning an array of `Proc`s.
+    #
+    # Wrapping this around anytime you call code which loads configurations
+    # will force a mutex so that procs never get mixed up. This keeps
+    # the configuration loading part of Vagrant thread-safe.
+    def self.capture_configures
+      CONFIGURE_MUTEX.synchronize do
+        # Reset the last procs so that we start fresh
+        @last_procs = []
+
+        # Yield to allow the caller to do whatever loading needed
+        yield
+
+        # Return the last procs we've seen while still in the mutex,
+        # knowing we're safe.
+        return @last_procs
+      end
+    end
+  end
+end

data/lib/vagrant/config/loader.rb

@@ -0,0 +1,222 @@
+require "pathname"
+
+require "log4r"
+
+module Vagrant
+  module Config
+    # This class is responsible for loading Vagrant configuration,
+    # usually in the form of Vagrantfiles.
+    #
+    # Loading works by specifying the sources for the configuration
+    # as well as the order the sources should be loaded. Configuration
+    # set later always overrides those set earlier; this is how
+    # configuration "scoping" is implemented.
+    class Loader
+      # 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.
+      #
+      # The `name` should be a symbol and must uniquely identify the data
+      # being given.
+      #
+      # `data` can either be a path to a Ruby Vagrantfile or a `Proc` directly.
+      # `data` can also be an array of such values.
+      #
+      # At this point, no configuration is actually loaded. Note that calling
+      # `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.info("Set #{name.inspect} = #{sources.inspect}")
+
+        # Sources should be an array
+        sources = [sources] if !sources.kind_of?(Array)
+
+        # Gather the procs for every source, since that is what we care about.
+        procs = []
+        sources.each do |source|
+          if !@proc_cache.has_key?(source)
+            # Load the procs for this source and cache them. This caching
+            # avoids the issue where a file may have side effects when loading
+            # and loading it multiple times causes unexpected behavior.
+            @logger.debug("Populating proc cache for #{source.inspect}")
+            @proc_cache[source] = procs_for_source(source)
+          end
+
+          # Add on to the array of procs we're going to use
+          procs.concat(@proc_cache[source])
+        end
+
+        # Set this source by name.
+        @sources[name] = procs
+      end
+
+      # This loads the configuration sources in the given order and returns
+      # an actual configuration object that is ready to be used.
+      #
+      # @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 - order
+        if !unknown_sources.empty?
+          # TODO: Raise exception here perhaps.
+          @logger.error("Unknown config sources: #{unknown_sources.inspect}")
+        end
+
+        # 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
+
+        # 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 |version, proc|
+            if !@config_cache.has_key?(proc)
+              @logger.debug("Loading from: #{key} (evaluating)")
+
+              # 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 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, finalizing and returning")
+        [current_config_klass.finalize(result), warnings, errors]
+      end
+
+      protected
+
+      # This returns an array of `Proc` objects for the given source.
+      # The `Proc` objects returned will expect a single argument for
+      # the configuration object and are expected to mutate this
+      # configuration object.
+      def procs_for_source(source)
+        # 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
+
+      # 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
+            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
+      end
+    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