class Vagrant::Config::Loader

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.

Public Class Methods

new(versions, version_order) click to toggle source

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.
# File lib/vagrant/config/loader.rb, line 23
def initialize(versions, version_order)
  @logger        = Log4r::Logger.new("vagrant::config::loader")
  @config_cache  = {}
  @proc_cache    = {}
  @sources       = {}
  @versions      = versions
  @version_order = version_order
end

Public Instance Methods

load(order) click to toggle source

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.
# File lib/vagrant/config/loader.rb, line 84
def load(order)
  @logger.info("Loading configuration in order: #{order.inspect}")

  unknown_sources = @sources.keys - order
  if !unknown_sources.empty?
    @logger.warn("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   = []

  if !@sources[:root].nil? && @sources[:root].eql?(@sources[:home])
    # Vagrants home dir is set to the same dir as its project directory
    # so we don't want to load and merge the same Vagrantfile config
    # and execute its settings/procs twice
    #
    # Note: This protection won't work if there are two separate but
    # identical Vagrantfiles in the home and project dir
    @logger.info("Duplicate Vagrantfile config objects detected in :root and :home.")
    @sources.delete(:home)
    @logger.info("Removed :home config from being loaded")
  end

  order.each do |key|
    next if !@sources.key?(key)

    @sources[key].each do |version, proc|
      if !@config_cache.key?(proc)
        @logger.debug("Loading from: #{key} (evaluating)")

        # Get the proper version loader for this version and load
        version_loader = @versions.get(version)
        begin
          version_config = version_loader.load(proc)
        rescue NameError => e
          line = "(unknown)"
          path = "(unknown)"
          if e.backtrace && e.backtrace[0]
            backtrace_tokens = e.backtrace[0].split(":")
            path = e.backtrace.first.slice(0, e.backtrace.first.rindex(':')).rpartition(':').first
            backtrace_tokens.each do |part|
              if part =~ /\d+/
                line = part.to_i
                break
              end
            end
          end

          raise Errors::VagrantfileNameError,
            path: path,
            line: line,
            message: e.message.sub(/' for .*$/, "'")
        end

        # 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
partial_load(key) click to toggle source

This method is used for doing partial loads of the Vagrantfile. It will load the contents of a single location and return the config. No merging is performed and no finalization is applied.

@param key [Symbol] name of location @return [Object] configuration @note: This will load either version, but we assume a v2 result @todo(spox): check version and raise error on v1

# File lib/vagrant/config/loader.rb, line 212
def partial_load(key)
  raise KeyError,
        "Unknown path key provided (#{key})" if !@sources.key?(key)

  version, proc = @sources[key].first
  @logger.debug("Loading from: #{key} (evaluating)")

  # Get the proper version loader for this version and load
  version_loader = @versions.get(version)
  raise KeyError,
        "Failed to create loader for requested version: #{version}" if version_loader.nil?

  begin
    version_config = version_loader.load(proc)
  rescue NameError => e
    line = "(unknown)"
    path = "(unknown)"
    if e.backtrace && e.backtrace[0]
      backtrace_tokens = e.backtrace[0].split(":")
      path = e.backtrace.first.slice(0, e.backtrace.first.rindex(':')).rpartition(':').first
      backtrace_tokens.each do |part|
        if part =~ /\d+/
          line = part.to_i
          break
        end
      end
    end

    raise Errors::VagrantfileNameError,
          path: path,
          line: line,
          message: e.message.sub(/' for .*$/, "'") + "\n#{e.backtrace.join("\n")}" + "\nVersion #{version.inspect} loader: #{version_loader.inspect} versions: #{@versions.inspect}"
  end
  version_config
end
set(name, sources) click to toggle source

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.

# File lib/vagrant/config/loader.rb, line 43
def set(name, sources)
  # Sources should be an array
  sources = [sources] if !sources.kind_of?(Array)

  reliably_inspected_sources = sources.reduce({}) { |accum, source|
    begin
      accum[source] = source.inspect
    rescue Encoding::CompatibilityError
      accum[source] = "<!Vagrant failed to call #inspect source with object id #{source.object_id} and class #{source.class} due to a string encoding error>"
    end

    accum
  }

  @logger.info("Set #{name.inspect} = #{reliably_inspected_sources.values}")

  # Gather the procs for every source, since that is what we care about.
  procs = []
  sources.each do |source|
    if !@proc_cache.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 #{reliably_inspected_sources[source]}")
      @proc_cache[source] = procs_for_source(source, reliably_inspected_sources)
    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

Protected Instance Methods

procs_for_path(path) click to toggle source

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>]

# File lib/vagrant/config/loader.rb, line 279
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"))

      line = "(unknown)"
      if e.backtrace && e.backtrace[0]
        e.backtrace[0].split(":").each do |part|
          if part =~ /\d+/
            line = part.to_i
            break
          end
        end
      end

      # Report the generic exception
      raise Errors::VagrantfileLoadError,
        path: path,
        line: line,
        exception_class: e.class,
        message: e.message
    end
  end
end
procs_for_source(source, reliably_inspected_sources) click to toggle source

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.

# File lib/vagrant/config/loader.rb, line 254
def procs_for_source(source, reliably_inspected_sources)
  # 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: #{reliably_inspected_sources[source]}"
  end
end