vagrantup 0.6.9 → 0.7.0

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

@@ -0,0 +1,56 @@
+module Vagrant
+  class 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
+          @shortcut = shortcut
+          @provisioner = shortcut
+          @provisioner = Provisioners::Base.registered[shortcut] if shortcut.is_a?(Symbol)
+          @config = nil
+
+          configure(options, &block)
+        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.set_options(options) if options
+          block.call(@config) if block
+        end
+
+        def validate(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))
+            return
+          end
+
+          if !(provisioner <= Provisioners::Base)
+            errors.add(I18n.t("vagrant.config.vm.provisioner_invalid_class", :shortcut => shortcut))
+          end
+
+          # Pass on validation to the provisioner config
+          config.validate(errors) if config
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Vagrant
+  class Config
+    class VMConfig < Base
+      # Represents a single sub-VM in a multi-VM environment.
+      class SubVM
+        include Util::StackedProcRunner
+
+        attr_reader :options
+
+        def initialize
+          @options = {}
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/config/vm.rb

@@ -1,3 +1,6 @@
+require 'vagrant/config/vm/sub_vm'
+require 'vagrant/config/vm/provisioner'
+
 module Vagrant
   class Config
     class VMConfig < Base
@@ -14,28 +17,17 @@ module Vagrant
       attr_reader :forwarded_ports
       attr_reader :shared_folders
       attr_reader :network_options
-      attr_reader :hd_location
+      attr_reader :provisioners
       attr_accessor :disk_image_format
-      attr_accessor :provisioner
       attr_writer :shared_folder_uid
       attr_writer :shared_folder_gid
       attr_accessor :system
 
-      # Represents a SubVM. This class is only used here in the VMs
-      # hash.
-      class SubVM
-        include Util::StackedProcRunner
-
-        def options
-          @options ||= {}
-        end
-      end
-
       def initialize
         @forwarded_ports = {}
         @shared_folders = {}
-        @provisioner = nil
         @network_options = []
+        @provisioners = []
       end
 
       def forward_port(name, guestport, hostport, options=nil)
@@ -68,6 +60,17 @@ module Vagrant
         @network_options[options[:adapter]] = options
       end
 
+      def provision(name, options=nil, &block)
+        @provisioners << Provisioner.new(top, name, options, &block)
+      end
+
+      # This shows an error message to smooth the transition for the
+      # backwards incompatible provisioner syntax change introduced
+      # in Vagrant 0.7.0.
+      def provisioner=(_value)
+        raise Errors::VagrantError, :_key => :provisioner_equals_not_supported
+      end
+
       def shared_folder_uid
         @shared_folder_uid || env.config.ssh.username
       end
@@ -95,14 +98,25 @@ module Vagrant
       end
 
       def define(name, options=nil, &block)
+        name = name.to_sym
         options ||= {}
+
+        # Add the name to the array of VM keys. This array is used to
+        # preserve the order in which VMs are defined.
         defined_vm_keys << name
-        defined_vms[name.to_sym] ||= SubVM.new
-        defined_vms[name.to_sym].options.merge!(options)
-        defined_vms[name.to_sym].push_proc(&block)
+
+        # 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)
       end
 
       def validate(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
+
         shared_folders.each do |name, options|
           if !File.directory?(File.expand_path(options[:hostpath].to_s, env.root_path))
             errors.add(I18n.t("vagrant.config.vm.shared_folder_hostpath_missing",
@@ -111,10 +125,10 @@ module Vagrant
           end
         end
 
-        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
+        # Each provisioner can validate itself
+        provisioners.each do |prov|
+          prov.validate(errors)
+        end
       end
     end
   end

data/lib/vagrant/config.rb

@@ -1,5 +1,13 @@
 require 'vagrant/config/base'
 require 'vagrant/config/error_recorder'
+require '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'
 
 module Vagrant
   # The config class is responsible for loading Vagrant configurations, which
@@ -17,157 +25,99 @@ module Vagrant
   # 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(env)
-  #     config.queue << "/path/to/some/Vagrantfile"
-  #     result = config.load!
+  #     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
-    extend Util::StackedProcRunner
-
-    @@config = nil
-
-    attr_reader :queue
-
-    class << self
-      # Resets the current loaded config object to the specified environment.
-      # This clears the proc stack and initializes a new {Top} for loading.
-      # This method shouldn't be called directly, instead use an instance of this
-      # class for config loading.
-      #
-      # @param [Environment] env
-      def reset!(env=nil)
-        @@config = nil
-        proc_stack.clear
+    # An array of symbols specifying the load order for the procs.
+    attr_accessor :load_order
+    attr_reader :procs
 
-        # Reset the configuration to the specified environment
-        config(env)
-      end
-
-      # Returns the current {Top} configuration object. While this is still
-      # here for implementation purposes, it shouldn't be called directly. Instead,
-      # use an instance of this class.
-      def config(env=nil)
-        @@config ||= Config::Top.new(env)
-      end
-
-      # Adds the given proc/block to the stack of config procs which are all
-      # run later on a single config object. This is the main way to configure
-      # Vagrant, and is how all Vagrantfiles are formatted:
-      #
-      #     Vagrant::Config.run do |config|
-      #       # ...
-      #     end
-      #
-      def run(&block)
-        push_proc(&block)
-      end
-
-      # Executes all the config procs onto the currently loaded {Top} object,
-      # and returns the final configured object. This also validates the
-      # configuration by calling {Top#validate!} on every configuration
-      # class.
-      def execute!
-        config_object ||= config
-        run_procs!(config_object)
-        config_object
-      end
+    # 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(&block)
+      # Store it for later
+      @last_procs ||= []
+      @last_procs << block
     end
 
-    # Initialize a {Config} object for the given {Environment}.
+    # 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.
     #
-    # @param [Environment] env Environment which config object will be part
-    #   of.
-    def initialize(env)
-      @env = env
-      @queue = []
+    # @return [Proc]
+    def self.last_proc
+      value = @last_procs
+      @last_procs = nil
+      value
     end
 
-    # Loads the queue of files/procs, executes them in the proper
-    # sequence, and returns the resulting configuration object.
-    def load!
-      self.class.reset!(@env)
+    def initialize(parent=nil)
+      @procs = {}
+      @load_order = []
 
-      queue.flatten.each do |item|
-        if item.is_a?(String) && File.exist?(item)
-          begin
-            load item
-          rescue SyntaxError => e
-            # Report syntax errors in a nice way for Vagrantfiles
-            raise Errors::VagrantfileSyntaxError, :file => e.message
-          end
-        elsif item.is_a?(Proc)
-          self.class.run(&item)
-        end
+      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
 
-      return self.class.execute!
+    # 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
-  end
 
-  class 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}
-    # and has accessors to all other configuration classes.
+    # 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.
     #
-    # If you're looking to create your own configuration class, see {Base}.
-    class Top < Base
-      @@configures = {} if !defined?(@@configures)
-
-      class << self
-        # The list of registered configuration classes as well as the key
-        # they're registered under.
-        def configures_list
-          @@configures ||= {}
-        end
-
-        # 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
+    # @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
 
-      def initialize(env=nil)
-        self.class.configures_list.each do |key, klass|
-          config = klass.new
-          config.env = env
-          config.top = self
-          instance_variable_set("@#{key}".to_sym, config)
-        end
+      config
+    end
 
-        @env = env
-      end
+    protected
 
-      # Validates the configuration classes of this instance and raises an
-      # exception if they are invalid. If you are implementing a custom configuration
-      # 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!
-        # Validate each of the configured classes and store the results into
-        # a hash.
-        errors = self.class.configures_list.inject({}) do |container, data|
-          key, _ = data
-          recorder = ErrorRecorder.new
-          send(key.to_sym).validate(recorder)
-          container[key.to_sym] = recorder if !recorder.errors.empty?
-          container
-        end
+    def proc_for(path)
+      return nil if !path
+      return path if path.is_a?(Proc)
 
-        return if errors.empty?
-        raise Errors::ConfigValidationFailed, :messages => Util::TemplateRenderer.render("config/validation_failed", :errors => errors)
+      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
       end
     end
   end
 end
-
-# 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'

data/lib/vagrant/downloaders/file.rb

@@ -14,6 +14,7 @@ module Vagrant
       end
 
       def download!(source_url, destination_file)
+        env.ui.info I18n.t("vagrant.downloaders.file.download")
         FileUtils.cp(source_url, destination_file.path)
       end
     end

data/lib/vagrant/downloaders/http.rb

@@ -25,7 +25,16 @@ module Vagrant
         end
 
         http.start do |h|
+          env.ui.info I18n.t("vagrant.downloaders.http.download", :url => source_url)
+
           h.request_get(uri.request_uri) do |response|
+            if response.is_a?(Net::HTTPRedirection)
+              # Follow the HTTP redirect.
+              # TODO: Error on some redirect limit
+              download!(response["Location"], destination_file)
+              return
+            end
+
             total = response.content_length
             progress = 0
             segment_count = 0

data/lib/vagrant/downloaders.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  module Downloaders
+    autoload :Base, 'vagrant/downloaders/base'
+    autoload :File, 'vagrant/downloaders/file'
+    autoload :HTTP, 'vagrant/downloaders/http'
+  end
+end

data/lib/vagrant/environment.rb

@@ -9,6 +9,7 @@ module Vagrant
     ROOTFILE_NAME = "Vagrantfile"
     HOME_SUBDIRS = ["tmp", "boxes", "logs"]
     DEFAULT_VM = :default
+    DEFAULT_HOME = "~/.vagrant"
 
     # Parent environment (in the case of multi-VMs)
     attr_reader :parent
@@ -23,6 +24,9 @@ module Vagrant
     # The {UI} object to communicate with the outside world.
     attr_writer :ui
 
+    # The {Config} object representing the Vagrantfile loader
+    attr_reader :config_loader
+
     #---------------------------------------------------------------
     # Class Methods
     #---------------------------------------------------------------
@@ -32,8 +36,7 @@ module Vagrant
       def check_virtualbox!
         version = VirtualBox.version
         raise Errors::VirtualBoxNotDetected if version.nil?
-        raise Errors::VirtualBoxInvalidVersion, :version => version.to_s if version.to_f < 3.2
-        raise Errors::VirtualBoxInvalidOSE, :version => version.to_s if version.to_s.downcase.include?("ose")
+        raise Errors::VirtualBoxInvalidVersion, :version => version.to_s if version.to_f < 4.0
       rescue Errors::VirtualBoxNotDetected
         # On 64-bit Windows, show a special error. This error is a subclass
         # of VirtualBoxNotDetected, so libraries which use Vagrant can just
@@ -79,12 +82,11 @@ module Vagrant
       root_path.join(config.vagrant.dotfile_name) rescue nil
     end
 
-    # The path to the home directory, expanded relative to the root path,
-    # and converted into a Pathname object.
+    # The path to the home directory and converted into a Pathname object.
     #
     # @return [Pathname]
     def home_path
-      @_home_path ||= Pathname.new(File.expand_path(config.vagrant.home, root_path))
+      @_home_path ||= Pathname.new(File.expand_path(ENV["VAGRANT_HOME"] || DEFAULT_HOME))
     end
 
     # The path to the Vagrant tmp directory
@@ -114,7 +116,8 @@ module Vagrant
     #
     # @return [String]
     def resource
-      vm.name rescue "vagrant"
+      result = vm.name rescue nil
+      result || "vagrant"
     end
 
     # Returns the collection of boxes for the environment.
@@ -146,7 +149,7 @@ module Vagrant
     #
     # @return [Array<VM>]
     def vms_ordered
-      @vms_enum ||= config.vm.defined_vm_keys.map {|name| @vms[name]}
+      @vms_enum ||= config.vm.defined_vm_keys.map { |name| @vms[name] }
     end
 
     # Returns the primary VM associated with this environment. This
@@ -305,6 +308,14 @@ module Vagrant
       self
     end
 
+    # Reloads the configuration of this environment.
+    def reload_config!
+      @config = nil
+      @config_loader = nil
+      load_config!
+      self
+    end
+
     # Loads this environment's configuration and stores it in the {#config}
     # variable. The configuration loaded by this method is specified to
     # this environment, meaning that it will use the given root directory
@@ -313,22 +324,23 @@ module Vagrant
       first_run = @config.nil?
 
       # First load the initial, non config-dependent Vagrantfiles
-      loader = Config.new(self)
-      loader.queue << File.expand_path("config/default.rb", Vagrant.source_root)
-      loader.queue << File.join(box.directory, ROOTFILE_NAME) if !first_run && box
-      loader.queue << File.join(home_path, ROOTFILE_NAME) if !first_run && home_path
-      loader.queue << File.join(root_path, ROOTFILE_NAME) if root_path
+      @config_loader ||= Config.new(parent ? parent.config_loader : nil)
+      @config_loader.load_order = [:default, :box, :home, :root, :sub_vm]
+      @config_loader.set(:default, File.expand_path("config/default.rb", Vagrant.source_root))
+      @config_loader.set(:box, File.join(box.directory, ROOTFILE_NAME)) if !first_run && vm && box
+      @config_loader.set(:home, File.join(home_path, ROOTFILE_NAME)) if !first_run && home_path
+      @config_loader.set(:root, File.join(root_path, ROOTFILE_NAME)) if root_path
 
       # If this environment is representing a sub-VM, then we push that
       # proc on as the last configuration.
       if vm
         subvm = parent.config.vm.defined_vms[vm.name]
-        loader.queue << subvm.proc_stack if subvm
+        @config_loader.set(:sub_vm, subvm.proc_stack) if subvm
       end
 
       # Execute the configuration stack and store the result as the final
       # value in the config ivar.
-      @config = loader.load!
+      @config = @config_loader.load(self)
 
       # (re)load the logger
       @logger = nil

data/lib/vagrant/errors.rb

@@ -230,16 +230,6 @@ module Vagrant
       error_key(:dotfile_error, "vagrant.actions.vm.persist")
     end
 
-    class ProvisionInvalidClass < VagrantError
-      status_code(35)
-      error_key(:invalid_class, "vagrant.actions.vm.provision")
-    end
-
-    class ProvisionUnknownType < VagrantError
-      status_code(36)
-      error_key(:unknown_type, "vagrant.actions.vm.provision")
-    end
-
     class SSHAuthenticationFailed < VagrantError
       status_code(11)
       error_key(:ssh_authentication_failed)
@@ -255,6 +245,11 @@ module Vagrant
       error_key(:ssh_key_bad_permissions)
     end
 
+    class SSHPortNotDetected < VagrantError
+      status_code(50)
+      error_key(:ssh_port_not_detected)
+    end
+
     class SSHUnavailable < VagrantError
       status_code(45)
       error_key(:ssh_unavailable)
@@ -275,11 +270,6 @@ module Vagrant
       error_key(:vagrantfile_syntax_error)
     end
 
-    class VirtualBoxInvalidOSE < VagrantError
-      status_code(9)
-      error_key(:virtualbox_invalid_ose)
-    end
-
     class VirtualBoxInvalidVersion < VagrantError
       status_code(17)
       error_key(:virtualbox_invalid_version)

data/lib/vagrant/hosts.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  module Hosts
+    autoload :Base,  'vagrant/hosts/base'
+    autoload :BSD,   'vagrant/hosts/bsd'
+    autoload :Linux, 'vagrant/hosts/linux'
+  end
+end

data/lib/vagrant/provisioners/base.rb

@@ -11,8 +11,26 @@ module Vagrant
       # {Vagrant::Action::Environment}
       attr_reader :action_env
 
-      def initialize(env)
+      # The configuration for this provisioner. This will be an instance of
+      # the `Config` class which is part of the provisioner.
+      attr_reader :config
+
+      # Registers a provisioner with a given shortcut. This allows that provisioner
+      # to be referenced with the shortcut.
+      #
+      # @param [Symbol] shortcut
+      def self.register(shortcut)
+        registered[shortcut] = self
+      end
+
+      # Returns the provisioner associated with the given shortcut.
+      def self.registered
+        @@registered ||= {}
+      end
+
+      def initialize(env, config)
         @action_env = env
+        @config = config
       end
 
       # Returns the actual {Vagrant::Environment} which this provisioner