vagrant 0.8.10 → 0.9.0

data/lib/vagrant/config.rb

@@ -1,46 +1,18 @@
-require 'vagrant/config/base'
-require 'vagrant/config/error_recorder'
-require 'vagrant/config/top'
+module Vagrant
+  module Config
+    autoload :Base,          'vagrant/config/base'
+    autoload :Container,     'vagrant/config/container'
+    autoload :ErrorRecorder, 'vagrant/config/error_recorder'
+    autoload :Loader,        'vagrant/config/loader'
+    autoload :Top,           'vagrant/config/top'
 
-# The built-in configuration classes
-require 'vagrant/config/vagrant'
-require 'vagrant/config/ssh'
-require 'vagrant/config/nfs'
-require 'vagrant/config/vm'
-require 'vagrant/config/package'
+    autoload :NFSConfig,     'vagrant/config/nfs'
+    autoload :PackageConfig, 'vagrant/config/package'
+    autoload :SSHConfig,     'vagrant/config/ssh'
+    autoload :VagrantConfig, 'vagrant/config/vagrant'
+    autoload :VMConfig,      'vagrant/config/vm'
 
-module Vagrant
-  # The config class is responsible for loading Vagrant configurations, which
-  # are usually found in Vagrantfiles but may also be procs. The loading is done
-  # by specifying a queue of files or procs that are for configuration, and then
-  # executing them. The config loader will run each item in the queue, so that
-  # configuration from later items overwrite that from earlier items. This is how
-  # Vagrant "scoping" of Vagranfiles is implemented.
-  #
-  # If you're looking to create your own configuration classes, see {Base}.
-  #
-  # # Loading Configuration Files
-  #
-  # If you are in fact looking to load configuration files, then this is the
-  # class you are looking for. Loading configuration is quite easy. The following
-  # example assumes `env` is already a loaded instance of {Environment}:
-  #
-  #     config = Vagrant::Config.new
-  #     config.set(:first, "/path/to/some/Vagrantfile")
-  #     config.set(:second, "/path/to/another/Vagrantfile")
-  #     config.load_order = [:first, :second]
-  #     result = config.load(env)
-  #
-  #     p "Your box is: #{result.vm.box}"
-  #
-  # The load order determines what order the config files specified are loaded.
-  # If a key is not mentioned (for example if above the load order was set to
-  # `[:first]`, therefore `:second` was not mentioned), then that config file
-  # won't be loaded.
-  class Config
-    # An array of symbols specifying the load order for the procs.
-    attr_accessor :load_order
-    attr_reader :procs
+    CONFIGURE_MUTEX = Mutex.new
 
     # This is the method which is called by all Vagrantfiles to configure Vagrant.
     # This method expects a block which accepts a single argument representing
@@ -54,69 +26,23 @@ module Vagrant
       @last_procs << block
     end
 
-    # Returns the last proc which was activated for the class via {run}. This
-    # also sets the last proc to `nil` so that calling this method multiple times
-    # will not return duplicates.
-    #
-    # @return [Proc]
-    def self.last_proc
-      value = @last_procs
-      @last_procs = nil
-      value
-    end
-
-    def initialize(parent=nil)
-      @procs = {}
-      @load_order = []
-
-      if parent
-        # Shallow copy the procs and load order from parent if given
-        @procs = parent.procs.dup
-        @load_order = parent.load_order.dup
-      end
-    end
-
-    # Adds a Vagrantfile to be loaded to the queue of config procs. Note
-    # that this causes the Vagrantfile file to be loaded at this point,
-    # and it will never be loaded again.
-    def set(key, path)
-      return if @procs.has_key?(key)
-      @procs[key] = [path].flatten.map(&method(:proc_for)).flatten
-    end
-
-    # Loads the added procs using the set `load_order` attribute and returns
-    # the {Config::Top} object result. The configuration is loaded for the
-    # given {Environment} object.
+    # This is a method which will yield to a block and will capture all
+    # ``Vagrant.configure`` calls, returning an array of `Proc`s.
     #
-    # @param [Environment] env
-    def load(env)
-      config = Top.new(env)
-
-      # Only run the procs specified in the load order, in the order
-      # specified.
-      load_order.each do |key|
-        if @procs[key]
-          @procs[key].each do |proc|
-            proc.call(config) if proc
-          end
-        end
-      end
-
-      config
-    end
-
-    protected
-
-    def proc_for(path)
-      return nil if !path
-      return path if path.is_a?(Proc)
-
-      begin
-        Kernel.load path if File.exist?(path)
-        return self.class.last_proc
-      rescue SyntaxError => e
-        # Report syntax errors in a nice way for Vagrantfiles
-        raise Errors::VagrantfileSyntaxError, :file => e.message
+    # 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

data/lib/vagrant/config/base.rb

@@ -1,22 +1,9 @@
 module Vagrant
-  class Config
+  module 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
-      # {Top} of this configuration stack
-      attr_accessor :top
-
-      # 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
@@ -29,14 +16,6 @@ module Vagrant
         end
       end
 
-      # A helper to access the environment that this configuration is for.
-      # This is obtained by getting the env from the {Top}.
-      #
-      # @return [Vagrant::Envrionment]
-      def env
-        top.env
-      end
-
       # Allows setting options from a hash. By default this simply calls
       # the `#{key}=` method on the config class with the value, which is
       # the expected behavior most of the time.
@@ -46,12 +25,26 @@ module Vagrant
         end
       end
 
+      # Merge another configuration object into this one.
+      #
+      # @param [Object] other The other configuration object to merge from,
+      #   this must be the same type of object as this one.
+      # @return [Object] The merged object.
+      def merge(other)
+        result = self.class.new
+        instance_variables_hash.merge(other.instance_variables_hash).each do |key, value|
+          result.instance_variable_set("@#{key}".to_sym, value)
+        end
+
+        result
+      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
+      def validate(env, errors); end
 
       # Converts the configuration to a raw hash by calling `#to_hash`
       # on all instance variables (if it can) and putting them into
@@ -69,14 +62,13 @@ module Vagrant
       # 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)
+        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 [:@env, :@top].include?(iv.to_sym)
+          acc[iv.to_s[1..-1]] = instance_variable_get(iv)
           acc
         end
       end

data/lib/vagrant/config/container.rb

@@ -0,0 +1,37 @@
+module Vagrant
+  module Config
+    # Contains loaded configuration values and provides access to those
+    # values.
+    #
+    # This is the class returned when loading configuration and stores
+    # the completely loaded configuration values. This class is meant to
+    # be immutable.
+    class Container
+      attr_reader :global
+      attr_reader :vms
+
+      # Initializes the configuration container.
+      #
+      # @param [Top] global Top-level configuration for the global
+      #   applicatoin.
+      # @param [Array] vms Array of VM configurations.
+      def initialize(global, vms)
+        @global = global
+        @vms    = []
+        @vm_configs = {}
+
+        vms.each do |vm_config|
+          @vms << vm_config.vm.name
+          @vm_configs[vm_config.vm.name] = vm_config
+        end
+      end
+
+      # This returns the configuration for a specific virtual machine.
+      # The values for this configuration are usually pertinent to a
+      # single virtual machine and do not affect the system globally.
+      def for_vm(name)
+        @vm_configs[name]
+      end
+    end
+  end
+end

data/lib/vagrant/config/error_recorder.rb

@@ -1,5 +1,5 @@
 module Vagrant
-  class Config
+  module 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.

data/lib/vagrant/config/loader.rb

@@ -0,0 +1,125 @@
+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
+      # 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 = {}
+      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.debug("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 configured sources in the configured order and returns
+      # an actual configuration object that is ready to be used.
+      def load
+        @logger.debug("Loading configuration in order: #{@load_order.inspect}")
+
+        unknown_sources = @sources.keys - @load_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
+
+        @load_order.each do |key|
+          next if !@sources.has_key?(key)
+
+          @sources[key].each do |proc|
+            if !@config_cache.has_key?(proc)
+              @logger.debug("Loading from: #{key} (evaluating)")
+              current = Top.new
+              proc.call(current)
+              @config_cache[proc] = current
+            end
+
+            # Merge in the results of this proc's configuration
+            result = result.merge(@config_cache[proc])
+          end
+        end
+
+        @logger.debug("Configuration loaded successfully")
+        result
+      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)
+        return [source] if source.is_a?(Proc)
+
+        # Assume all string sources are actually pathnames
+        source = Pathname.new(source) if source.is_a?(String)
+
+        if source.is_a?(Pathname)
+          @logger.debug("Load procs for pathname: #{source.inspect}")
+
+          begin
+            return Config.capture_configures do
+              Kernel.load source
+            end
+          rescue SyntaxError => e
+            # Report syntax errors in a nice way.
+            raise Errors::VagrantfileSyntaxError, :file => e.message
+          end
+        end
+
+        raise Exception, "Unknown configuration source: #{source.inspect}"
+      end
+    end
+  end
+end

data/lib/vagrant/config/nfs.rb

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

data/lib/vagrant/config/package.rb

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

data/lib/vagrant/config/ssh.rb

@@ -1,37 +1,52 @@
 module Vagrant
-  class Config
+  module Config
     class SSHConfig < Base
-      configures :ssh
-
       attr_accessor :username
+      attr_accessor :password
       attr_accessor :host
-      attr_accessor :forwarded_port_key
-      attr_accessor :forwarded_port_destination
+      attr_accessor :port
+      attr_accessor :guest_port
       attr_accessor :max_tries
       attr_accessor :timeout
-      attr_writer :private_key_path
+      attr_accessor :private_key_path
       attr_accessor :forward_agent
       attr_accessor :forward_x11
       attr_accessor :shell
-      attr_accessor :port
 
       def initialize
-        @shell = "bash"
-        @port = nil
-        @forward_agent = false
-        @forward_x11 = false
+        @shell            = "bash"
+        @forward_agent    = false
+        @forward_x11      = false
       end
 
-      def private_key_path
-        File.expand_path(@private_key_path, env.root_path)
+      def forwarded_port_key=(value)
+        raise Errors::DeprecationError, :message => <<-MESSAGE
+`config.ssh.forwarded_port_key` is now gone. You must now use
+`config.ssh.guest_port` which is expected to be the port on the
+guest that SSH is listening on. Vagrant will automatically scan
+the forwarded ports to look for a forwarded port from this port
+and use it.
+        MESSAGE
       end
 
-      def validate(errors)
-        [:username, :host, :forwarded_port_key, :max_tries, :timeout, :private_key_path].each do |field|
+      def forwarded_port_destination=(value)
+        raise Errors::DeprecationError, :message => <<-MESSAGE
+`config.ssh.forwarded_port_destination` is now gone. You must now use
+`config.ssh.guest_port` which is expected to be the port on the
+guest that SSH is listening on. Vagrant will automatically scan
+the forwarded ports to look for a forwarded port from this port
+and use it.
+        MESSAGE
+      end
+
+      def validate(env, errors)
+        [:username, :host, :max_tries, :timeout].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)
+        if private_key_path && !File.file?(private_key_path)
+          errors.add(I18n.t("vagrant.config.ssh.private_key_missing", :path => private_key_path))
+        end
       end
     end
   end