vagrantup 0.8.10 → 0.9.0

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

data/lib/vagrant/config/top.rb

@@ -1,5 +1,5 @@
 module Vagrant
-  class Config
+  module Config
     # This class is the "top" configure class, which handles registering
     # other configuration classes as well as validation of all configured
     # classes. This is the object which is returned by {Environment#config}
@@ -7,34 +7,45 @@ module Vagrant
     #
     # If you're looking to create your own configuration class, see {Base}.
     class Top < Base
-      @@configures = {} if !defined?(@@configures)
+      attr_reader :keys
 
-      # The environment that this configuration is for.
-      attr_reader :env
+      def initialize(registry=nil)
+        @keys = {}
+        @registry = registry || Vagrant.config_keys
+      end
 
-      class << self
-        # The list of registered configuration classes as well as the key
-        # they're registered under.
-        def configures_list
-          @@configures ||= {}
-        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)
 
-        # Registers a configuration class with the given key. This method shouldn't
-        # be called. Instead, inherit from {Base} and call {Base.configures}.
-        def configures(key, klass)
-          configures_list[key] = klass
-          attr_reader key.to_sym
+        config_klass = @registry.get(name.to_sym)
+        if config_klass
+          # Instantiate the class and return the instance
+          @keys[name] = config_klass.new
+          return @keys[name]
+        else
+          # Super it up to probably raise a NoMethodError
+          super
         end
       end
 
-      def initialize(env=nil)
-        self.class.configures_list.each do |key, klass|
-          config = klass.new
-          config.top = self
-          instance_variable_set("@#{key}".to_sym, config)
+      # Custom implementation to merge each key separately.
+      def merge(other)
+        result = self.class.new
+        @keys.each do |key, value|
+          result.keys[key] = value.merge(other.send(key))
+        end
+
+        other.keys.each do |key, value|
+          if !@keys.has_key?(key)
+            # This is a key that the other configuration class has
+            # that we don't, so just copy it in.
+            result.keys[key] = value.dup
+          end
         end
 
-        @env = env
+        result
       end
 
       # Validates the configuration classes of this instance and raises an
@@ -42,13 +53,13 @@ module Vagrant
       # class, the method you want to implement is {Base#validate}. This is
       # the method that checks all the validation, not one which defines
       # validation rules.
-      def validate!
+      def validate!(env)
         # Validate each of the configured classes and store the results into
         # a hash.
-        errors = self.class.configures_list.inject({}) do |container, data|
-          key, _ = data
+        errors = @keys.inject({}) do |container, data|
+          key, instance = data
           recorder = ErrorRecorder.new
-          send(key.to_sym).validate(recorder)
+          instance.validate(env, recorder)
           container[key.to_sym] = recorder if !recorder.errors.empty?
           container
         end

data/lib/vagrant/config/vagrant.rb

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

data/lib/vagrant/config/vm/provisioner.rb

@@ -1,42 +1,38 @@
+require 'log4r'
+
 module Vagrant
-  class Config
+  module Config
     class VMConfig < Base
       # Represents a single configured provisioner for a VM.
       class Provisioner
-        attr_reader :top
         attr_reader :shortcut
         attr_reader :provisioner
         attr_reader :config
 
-        def initialize(top, shortcut, options=nil, &block)
-          @top = top
+        def initialize(shortcut, options=nil, &block)
+          @logger = Log4r::Logger.new("vagrant::config::vm::provisioner")
+          @logger.debug("Provisioner config: #{shortcut}")
           @shortcut = shortcut
           @provisioner = shortcut
-          @provisioner = Provisioners::Base.registered[shortcut] if shortcut.is_a?(Symbol)
+          @provisioner = Vagrant.provisioners.get(shortcut) if shortcut.is_a?(Symbol)
           @config = nil
 
-          configure(options, &block)
+          @logger.info("Provisioner class: #{provisioner}")
+          configure(options, &block) if @provisioner
         end
 
         # Configures the provisioner if it can (if it is valid).
         def configure(options=nil, &block)
-          # We don't want ancestors to be searched. This is the default in 1.8,
-          # but not in 1.9, hence this hackery.
-          const_args = ["Config"]
-          const_args << false if RUBY_VERSION >= "1.9"
-
-          # We assume that every provisioner has a `Config` class beneath
-          # it for configuring.
-          return if !@provisioner || !@provisioner.const_defined?(*const_args)
-
-          # Instantiate the config class and configure it
-          @config = @provisioner.const_get(*const_args).new
-          @config.top = top
+          config_class = @provisioner.config_class
+          return if !config_class
+
+          @logger.debug("Configuring provisioner with: #{config_class}")
+          @config = config_class.new
           @config.set_options(options) if options
           block.call(@config) if block
         end
 
-        def validate(errors)
+        def validate(env, errors)
           if !provisioner
             # If we don't have a provisioner then the whole thing is invalid.
             errors.add(I18n.t("vagrant.config.vm.provisioner_not_found", :shortcut => shortcut))
@@ -48,7 +44,7 @@ module Vagrant
           end
 
           # Pass on validation to the provisioner config
-          config.validate(errors) if config
+          config.validate(env, errors) if config
         end
       end
     end

data/lib/vagrant/config/vm/sub_vm.rb

@@ -1,5 +1,5 @@
 module Vagrant
-  class Config
+  module Config
     class VMConfig < Base
       # Represents a single sub-VM in a multi-VM environment.
       class SubVM

data/lib/vagrant/config/vm.rb

@@ -1,77 +1,120 @@
+require 'pathname'
+
 require 'vagrant/config/vm/sub_vm'
 require 'vagrant/config/vm/provisioner'
 
 module Vagrant
-  class Config
+  module Config
     class VMConfig < Base
-      configures :vm
-
-      include Util::StackedProcRunner
-
+      attr_accessor :name
       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_accessor :host_name
       attr_reader :forwarded_ports
       attr_reader :shared_folders
-      attr_reader :network_options
+      attr_reader :networks
       attr_reader :provisioners
-      attr_accessor :system
+      attr_reader :customizations
+      attr_accessor :guest
 
       def initialize
-        @forwarded_ports = {}
+        @forwarded_ports = []
         @shared_folders = {}
-        @network_options = []
+        @networks = []
         @provisioners = []
+        @customizations = []
       end
 
-      def forward_port(name, guestport, hostport, options=nil)
-        options = {
+      # Custom merge method since some keys here are merged differently.
+      def merge(other)
+        result = super
+        result.instance_variable_set(:@forwarded_ports, @forwarded_ports + other.forwarded_ports)
+        result.instance_variable_set(:@shared_folders, @shared_folders.merge(other.shared_folders))
+        result.instance_variable_set(:@networks, @networks + other.networks)
+        result.instance_variable_set(:@provisioners, @provisioners + other.provisioners)
+        result.instance_variable_set(:@customizations, @customizations + other.customizations)
+        result
+      end
+
+      def forward_port(guestport, hostport, options=nil)
+        if !guestport.kind_of?(Integer)
+          raise Errors::DeprecationError, :message => <<-MESSAGE
+`config.vm.forward_port` changed in 0.9.0 where the required name
+argument is now removed. Vagrant will now automatically generate
+a unique name for your forwarded port. For example, to forward
+port 80 to port 8080 you now do the following:
+
+    config.vm.forward_port 80, 8080
+
+Please change your configurations to match this new syntax.
+          MESSAGE
+        end
+
+        @forwarded_ports << {
+          :name       => "#{guestport.to_s(32)}-#{hostport.to_s(32)}",
           :guestport  => guestport,
           :hostport   => hostport,
           :protocol   => :tcp,
-          :adapter    => 0,
+          :adapter    => 1,
           :auto       => false
         }.merge(options || {})
-
-        forwarded_ports[name] = options
       end
 
       def share_folder(name, guestpath, hostpath, opts=nil)
         @shared_folders[name] = {
-          :guestpath => guestpath,
-          :hostpath => hostpath,
+          :guestpath => guestpath.to_s,
+          :hostpath => hostpath.to_s,
+          :create => false,
           :owner => nil,
           :group => nil,
-          :nfs   => false
+          :nfs   => false,
+          :extra => nil
         }.merge(opts || {})
       end
 
-      def network(ip, options=nil)
-        options = {
-          :ip => ip,
-          :netmask => "255.255.255.0",
-          :adapter => 1,
-          :mac => nil,
-          :name => nil
-        }.merge(options || {})
+      def network(type, *args)
+        if !type.kind_of?(Symbol)
+          raise Errors::DeprecationError, :message => <<-MESSAGE
+`config.vm.network` changed in 0.9.0 where the first argument is
+now the type of network and the remaining arguments are options for
+that type. For example, host only networks are now configured like
+so:
 
-        @network_options[options[:adapter]] = options
+    config.vm.network :hostonly, "172.24.24.24"
+
+Please change your configurations to match this new syntax.
+          MESSAGE
+        end
+
+        @networks << [type, args]
       end
 
       def provision(name, options=nil, &block)
-        @provisioners << Provisioner.new(top, name, options, &block)
+        @provisioners << Provisioner.new(name, options, &block)
       end
 
-      def customize(&block)
-        push_proc(&block)
-      end
+      # TODO: This argument should not be `nil` in the future.
+      # It is only defaulted to nil so that the deprecation error
+      # can be properly shown.
+      def customize(command=nil)
+        if block_given?
+          raise Errors::DeprecationError, :message => <<-MESSAGE
+`config.vm.customize` now takes an array of arguments to send to
+`VBoxManage` instead of having a block which gets a virtual machine
+object. Example of the new usage:
+
+    config.vm.customize ["modifyvm", :id, "--memory", "1024"]
+
+The above will run `VBoxManage modifyvm 1234 --memory 1024` where
+"1234" is the ID of your current virtual machine. Anything you could
+do before is certainly still possible with `VBoxManage` as well.
+          MESSAGE
+        end
 
-      def has_multi_vms?
-        !defined_vms.empty?
+        @customizations << command if command
       end
 
       def defined_vms
@@ -95,17 +138,19 @@ module Vagrant
         # Add the SubVM to the hash of defined VMs
         defined_vms[name] ||= SubVM.new
         defined_vms[name].options.merge!(options)
-        defined_vms[name].push_proc(&block)
+        defined_vms[name].push_proc(&block) if block
       end
 
-      def validate(errors)
+      def validate(env, errors)
         errors.add(I18n.t("vagrant.config.vm.box_missing")) if !box
-        errors.add(I18n.t("vagrant.config.vm.box_not_found", :name => box)) if box && !box_url && !env.box
-        errors.add(I18n.t("vagrant.config.vm.boot_mode_invalid")) if ![:vrdp, :gui].include?(boot_mode.to_sym)
-        errors.add(I18n.t("vagrant.config.vm.base_mac_invalid")) if env.box && !base_mac
+        errors.add(I18n.t("vagrant.config.vm.box_not_found", :name => box)) if box && !box_url && !env.boxes.find(box)
+        errors.add(I18n.t("vagrant.config.vm.boot_mode_invalid")) if ![:headless, :gui].include?(boot_mode.to_sym)
+        errors.add(I18n.t("vagrant.config.vm.base_mac_invalid")) if env.boxes.find(box) && !base_mac
 
         shared_folders.each do |name, options|
-          if !File.directory?(File.expand_path(options[:hostpath].to_s, env.root_path))
+          hostpath = Pathname.new(options[:hostpath]).expand_path(env.root_path)
+
+          if !hostpath.directory? && !options[:create]
             errors.add(I18n.t("vagrant.config.vm.shared_folder_hostpath_missing",
                        :name => name,
                        :path => options[:hostpath]))
@@ -119,28 +164,42 @@ module Vagrant
         end
 
         # Validate some basic networking
-        network_options.each do |options|
-          next if !options
-
-          ip = options[:ip].split(".")
-
-          if ip.length != 4
-            errors.add(I18n.t("vagrant.config.vm.network_ip_invalid",
-                              :ip => options[:ip]))
-          elsif ip.last == "1"
-            errors.add(I18n.t("vagrant.config.vm.network_ip_ends_one",
-                              :ip => options[:ip]))
+        #
+        # TODO: One day we need to abstract this out, since in the future
+        # providers other than VirtualBox will not be able to satisfy
+        # all types of networks.
+        networks.each do |type, args|
+          if type == :hostonly && args[0] == :dhcp
+            # Valid. There is no real way this can be invalid at the moment.
+          elsif type == :hostonly
+            # Validate the host-only network
+            ip      = args[0]
+            options = args[1] || {}
+
+            if !ip
+              errors.add(I18n.t("vagrant.config.vm.network_ip_required"))
+            else
+              ip_parts = ip.split(".")
+
+              if ip_parts.length != 4
+                errors.add(I18n.t("vagrant.config.vm.network_ip_invalid",
+                                  :ip => ip))
+              elsif ip_parts.last == "1"
+                errors.add(I18n.t("vagrant.config.vm.network_ip_ends_one",
+                                  :ip => ip))
+              end
+            end
+          elsif type == :bridged
+          else
+            # Invalid network type
+            errors.add(I18n.t("vagrant.config.vm.network_invalid",
+                              :type => type.to_s))
           end
         end
 
         # Each provisioner can validate itself
         provisioners.each do |prov|
-          # TODO: Remove at some point
-          if prov.shortcut == :chef_server
-            errors.add(I18n.t("vagrant.config.vm.provisioner_chef_server_changed"))
-          else
-            prov.validate(errors)
-          end
+          prov.validate(env, errors)
         end
       end
     end

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