vagrant 0.7.8 → 0.8.1

data/lib/vagrant/action/vm/provision.rb

@@ -2,37 +2,30 @@ module Vagrant
   class Action
     module VM
       class Provision
-        attr_reader :provisioners
-
         def initialize(app, env)
           @app = app
           @env = env
           @env["provision.enabled"] = true if !@env.has_key?("provision.enabled")
-          @provisioners = []
-
-          load_provisioners if provisioning_enabled?
         end
 
         def call(env)
+          # Instantiate and prepare the provisioners. Preparation must happen here
+          # so that shared folders and such can properly take effect.
+          provisioners = enabled_provisioners
+          provisioners.map { |p| p.prepare }
+
           @app.call(env)
 
-          @provisioners.each do |instance|
+          # Take prepared provisioners and run the provisioning
+          provisioners.each do |instance|
             @env.ui.info I18n.t("vagrant.actions.vm.provision.beginning", :provisioner => instance.class)
             instance.provision!
           end
         end
 
-        def provisioning_enabled?
-          !@env["config"].vm.provisioners.empty? && @env["provision.enabled"]
-        end
-
-        def load_provisioners
-          @env["config"].vm.provisioners.each do |provisioner|
-            @env.ui.info I18n.t("vagrant.actions.vm.provision.enabled", :provisioner => provisioner.shortcut)
-
-            instance = provisioner.provisioner.new(@env, provisioner.config)
-            instance.prepare
-            @provisioners << instance
+        def enabled_provisioners
+          @env["config"].vm.provisioners.map do |provisioner|
+            provisioner.provisioner.new(@env, provisioner.config)
           end
         end
       end

data/lib/vagrant/action/vm/provisioner_cleanup.rb

@@ -0,0 +1,26 @@
+module Vagrant
+  class Action
+    module VM
+      class ProvisionerCleanup
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          enabled_provisioners.each do |instance|
+            instance.cleanup
+          end
+
+          @app.call(env)
+        end
+
+        def enabled_provisioners
+          @env["config"].vm.provisioners.map do |provisioner|
+            provisioner.provisioner.new(@env, provisioner.config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/share_folders.rb

@@ -33,16 +33,18 @@ module Vagrant
         end
 
         def create_metadata
-          @env.ui.info I18n.t("vagrant.actions.vm.share_folders.creating")
+          proc = lambda do |vm|
+            @env.ui.info I18n.t("vagrant.actions.vm.share_folders.creating")
 
-          shared_folders.each do |name, data|
-            folder = VirtualBox::SharedFolder.new
-            folder.name = name
-            folder.host_path = File.expand_path(data[:hostpath], @env.env.root_path)
-            @env["vm"].vm.shared_folders << folder
+            shared_folders.each do |name, data|
+              folder = VirtualBox::SharedFolder.new
+              folder.name = name
+              folder.host_path = File.expand_path(data[:hostpath], @env.env.root_path)
+              vm.shared_folders << folder
+            end
           end
 
-          @env["vm"].vm.save
+          @env["vm.modify"].call(proc)
         end
 
         def mount_shared_folders
@@ -55,7 +57,13 @@ module Vagrant
                 @env.ui.info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
                                     :name => name,
                                     :guest_path => data[:guestpath]))
-                @env["vm"].system.mount_shared_folder(ssh, name, data[:guestpath])
+
+                # Calculate the owner and group
+                owner = data[:owner] || @env["config"].ssh.username
+                group = data[:group] || @env["config"].ssh.username
+
+                # Mount the actual folder
+                @env["vm"].system.mount_shared_folder(ssh, name, data[:guestpath], owner, group)
               else
                 # If no guest path is specified, then automounting is disabled
                 @env.ui.info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",

data/lib/vagrant/action/warden.rb

@@ -25,13 +25,16 @@ module Vagrant
           # Call the next middleware in the sequence, appending to the stack
           # of "recoverable" middlewares in case something goes wrong!
           raise Errors::VagrantInterrupt if env.interrupted?
-          @stack.unshift(@actions.shift).first.call(env)
+          action = @actions.shift
+          env["logger"].info("warden") { "Calling action: #{action}" }
+          @stack.unshift(action).first.call(env)
           raise Errors::VagrantInterrupt if env.interrupted?
         rescue SystemExit
           # This means that an "exit" or "abort" was called. In these cases,
           # we just exit immediately.
           raise
         rescue Exception => e
+          env["logger"].info("warden") { "Error occurred: #{e}" }
           env["vagrant.error"] = e
 
           # Something went horribly wrong. Start the rescue chain then
@@ -46,7 +49,10 @@ module Vagrant
       # which has already run, in reverse order.
       def begin_rescue(env)
         @stack.each do |act|
-          act.recover(env) if act.respond_to?(:recover)
+          if act.respond_to?(:recover)
+            env["logger"].info("warden") { "Calling recover: #{act}" }
+            act.recover(env)
+          end
         end
 
         # Clear stack so that warden down the middleware chain doesn't

data/lib/vagrant/command/ssh.rb

@@ -1,11 +1,11 @@
 module Vagrant
   module Command
     class SSHCommand < NamedBase
-      class_option :execute, :type => :string, :default => false, :aliases => "-e"
+      class_option :command, :type => :string, :default => false, :aliases => "-c"
       register "ssh", "SSH into the currently running Vagrant environment."
 
       def execute
-        if options[:execute]
+        if options[:command]
           ssh_execute
         else
           ssh_connect
@@ -16,8 +16,8 @@ module Vagrant
 
       def ssh_execute
         ssh_vm.ssh.execute do |ssh|
-          ssh_vm.env.ui.info I18n.t("vagrant.commands.ssh.execute", :command => options[:execute])
-          ssh.exec!(options[:execute]) do |channel, type, data|
+          ssh_vm.env.ui.info I18n.t("vagrant.commands.ssh.command", :command => options[:command])
+          ssh.exec!(options[:command]) do |channel, type, data|
             ssh_vm.env.ui.info "#{data}"
           end
         end

data/lib/vagrant/command/ssh_config.rb

@@ -14,11 +14,13 @@ module Vagrant
         vm.ssh.check_key_permissions(vm.env.config.ssh.private_key_path)
 
         $stdout.puts(Util::TemplateRenderer.render("ssh_config", {
-          :host_key => options[:host] || "vagrant",
+          :host_key => options[:host] || vm.name || "vagrant",
           :ssh_host => vm.env.config.ssh.host,
           :ssh_user => vm.env.config.ssh.username,
           :ssh_port => vm.ssh.port,
-          :private_key_path => vm.env.config.ssh.private_key_path
+          :private_key_path => vm.env.config.ssh.private_key_path,
+          :forward_agent => vm.env.config.ssh.forward_agent,
+          :forward_x11   => vm.env.config.ssh.forward_x11
         }))
       end
     end

data/lib/vagrant/config/ssh.rb

@@ -6,6 +6,7 @@ module Vagrant
       attr_accessor :username
       attr_accessor :host
       attr_accessor :forwarded_port_key
+      attr_accessor :forwarded_port_destination
       attr_accessor :max_tries
       attr_accessor :timeout
       attr_writer :private_key_path
@@ -17,6 +18,8 @@ module Vagrant
       def initialize
         @sudo_shell = "bash"
         @port = nil
+        @forward_agent = false
+        @forward_x11 = false
       end
 
       def private_key_path

data/lib/vagrant/config/vm.rb

@@ -20,8 +20,6 @@ module Vagrant
       attr_reader :network_options
       attr_reader :provisioners
       attr_accessor :disk_image_format
-      attr_writer :shared_folder_uid
-      attr_writer :shared_folder_gid
       attr_accessor :system
 
       def initialize
@@ -46,7 +44,10 @@ module Vagrant
       def share_folder(name, guestpath, hostpath, opts=nil)
         @shared_folders[name] = {
           :guestpath => guestpath,
-          :hostpath => hostpath
+          :hostpath => hostpath,
+          :owner => nil,
+          :group => nil,
+          :nfs   => false
         }.merge(opts || {})
       end
 
@@ -73,14 +74,6 @@ module Vagrant
         raise Errors::VagrantError, :_key => :provisioner_equals_not_supported
       end
 
-      def shared_folder_uid
-        @shared_folder_uid || env.config.ssh.username
-      end
-
-      def shared_folder_gid
-        @shared_folder_gid || env.config.ssh.username
-      end
-
       def customize(&block)
         push_proc(&block)
       end
@@ -125,11 +118,22 @@ module Vagrant
                        :name => name,
                        :path => options[:hostpath]))
           end
+
+          if options[:nfs] && (options[:owner] || options[:group])
+            # Owner/group don't work with NFS
+            errors.add(I18n.t("vagrant.config.vm.shared_folder_nfs_owner_group",
+                              :name => name))
+          end
         end
 
         # Each provisioner can validate itself
         provisioners.each do |prov|
-          prov.validate(errors)
+          # 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
         end
       end
     end

data/lib/vagrant/downloaders/http.rb

@@ -33,6 +33,8 @@ module Vagrant
               # TODO: Error on some redirect limit
               download!(response["Location"], destination_file)
               return
+            elsif !response.is_a?(Net::HTTPOK)
+              raise Errors::DownloaderHTTPStatusError, :status => response.code
             end
 
             total = response.content_length

data/lib/vagrant/environment.rb

@@ -1,15 +1,15 @@
 require 'pathname'
 require 'fileutils'
+require 'logger'
 
 module Vagrant
   # Represents a single Vagrant environment. A "Vagrant environment" is
   # defined as basically a folder with a "Vagrantfile." This class allows
   # access to the VMs, CLI, etc. all in the scope of this environment.
   class Environment
-    ROOTFILE_NAME = "Vagrantfile"
     HOME_SUBDIRS = ["tmp", "boxes", "logs"]
     DEFAULT_VM = :default
-    DEFAULT_HOME = "~/.vagrant"
+    DEFAULT_HOME = "~/.vagrant.d"
 
     # Parent environment (in the case of multi-VMs)
     attr_reader :parent
@@ -17,6 +17,9 @@ module Vagrant
     # The `cwd` that this environment represents
     attr_reader :cwd
 
+    # The valid name for a Vagrantfile for this environment.
+    attr_reader :vagrantfile_name
+
     # The single VM that this environment represents, in the case of
     # multi-VM.
     attr_accessor :vm
@@ -36,7 +39,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 < 4.0 || version.to_f >= 4.1
+        raise Errors::VirtualBoxInvalidVersion, :version => version.to_s if version.to_f < 4.1 || version.to_f >= 4.2
       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
@@ -58,16 +61,30 @@ module Vagrant
         :parent => nil,
         :vm => nil,
         :cwd => nil,
+        :vagrantfile_name => nil,
+        :lock_path => nil
       }.merge(opts || {})
 
+      # Set the default working directory to look for the vagrantfile
       opts[:cwd] ||= Dir.pwd
       opts[:cwd] = Pathname.new(opts[:cwd])
 
+      # Set the default vagrantfile name, which can be either Vagrantfile
+      # or vagrantfile (capital for backwards compatibility)
+      opts[:vagrantfile_name] ||= ["Vagrantfile", "vagrantfile"]
+      opts[:vagrantfile_name] = [opts[:vagrantfile_name]] if !opts[:vagrantfile_name].is_a?(Array)
+
       opts.each do |key, value|
         instance_variable_set("@#{key}".to_sym, opts[key])
       end
 
       @loaded = false
+      @lock_acquired = false
+
+      logger.info("environment") { "Environment initialized (#{self})" }
+      logger.info("environment") { "  - cwd: #{cwd}" }
+      logger.info("environment") { "  - parent: #{parent}" }
+      logger.info("environment") { "  - vm: #{vm}" }
     end
 
     #---------------------------------------------------------------
@@ -86,7 +103,33 @@ module Vagrant
     #
     # @return [Pathname]
     def home_path
+      return parent.home_path if parent
+      return @_home_path if defined?(@_home_path)
+
       @_home_path ||= Pathname.new(File.expand_path(ENV["VAGRANT_HOME"] || DEFAULT_HOME))
+      logger.info("environment") { "Home path: #{@_home_path}" }
+
+      # This is the old default that Vagrant used to be put things into
+      # up until Vagrant 0.8.0. We keep around an automatic migration
+      # script here in case any old users upgrade.
+      old_home = File.expand_path("~/.vagrant")
+      if File.exists?(old_home) && File.directory?(old_home)
+        logger.info("environment") { "Found both an old and new Vagrantfile. Migration initiated." }
+
+        # We can't migrate if the home directory already exists
+        if File.exists?(@_home_path)
+          ui.warn I18n.t("vagrant.general.home_dir_migration_failed",
+                         :old => old_home,
+                         :new => @_home_path.to_s)
+        else
+          # If the new home path doesn't exist, simply transition to it
+          ui.info I18n.t("vagrant.general.moving_home_dir", :directory => @_home_path)
+          FileUtils.mv(old_home, @_home_path)
+        end
+      end
+
+      # Return the home path
+      @_home_path
     end
 
     # The path to the Vagrant tmp directory
@@ -249,7 +292,27 @@ module Vagrant
     # @return [Logger]
     def logger
       return parent.logger if parent
-      @logger ||= Util::ResourceLogger.new(resource, self)
+      return @logger if @logger
+
+      # Figure out where the output should go to.
+      output = nil
+      if ENV["VAGRANT_LOG"] == "STDOUT"
+        output = STDOUT
+      elsif ENV["VAGRANT_LOG"] == "NULL"
+        output = nil
+      elsif ENV["VAGRANT_LOG"]
+        output = ENV["VAGRANT_LOG"]
+      else
+        output = nil #log_path.join("#{Time.now.to_i}.log")
+      end
+
+      # Create the logger and custom formatter
+      @logger = Logger.new(output)
+      @logger.formatter = Proc.new do |severity, datetime, progname, msg|
+        "#{datetime} - #{progname} - [#{resource}] #{msg}\n"
+      end
+
+      @logger
     end
 
     # The root path is the path where the top-most (loaded last)
@@ -261,7 +324,13 @@ module Vagrant
       return @root_path if defined?(@root_path)
 
       root_finder = lambda do |path|
-        return path if File.exist?(File.join(path.to_s, ROOTFILE_NAME))
+        # Note: To remain compatible with Ruby 1.8, we have to use
+        # a `find` here instead of an `each`.
+        found = vagrantfile_name.find do |rootfile|
+          File.exist?(File.join(path.to_s, rootfile))
+        end
+
+        return path if found
         return nil if path.root? || !File.exist?(path)
         root_finder.call(path.parent)
       end
@@ -269,6 +338,39 @@ module Vagrant
       @root_path = root_finder.call(cwd)
     end
 
+    # This returns the path which Vagrant uses to determine the location
+    # of the file lock. This is specific to each operating system.
+    def lock_path
+      @lock_path || tmp_path.join("vagrant.lock")
+    end
+
+    # This locks Vagrant for the duration of the block passed to this
+    # method. During this time, any other environment which attempts
+    # to lock which points to the same lock file will fail.
+    def lock
+      # This allows multiple locks in the same process to be nested
+      return yield if @lock_acquired
+
+      File.open(lock_path, "w+") do |f|
+        # The file locking fails only if it returns "false." If it
+        # succeeds it returns a 0, so we must explicitly check for
+        # the proper error case.
+        raise Errors::EnvironmentLockedError if f.flock(File::LOCK_EX | File::LOCK_NB) === false
+
+        begin
+          # Mark that we have a lock
+          @lock_acquired = true
+
+          yield
+        ensure
+          # We need to make sure that no matter what this is always
+          # reset to false so we don't think we have a lock when we
+          # actually don't.
+          @lock_acquired = false
+        end
+      end
+    end
+
     #---------------------------------------------------------------
     # Config Methods
     #---------------------------------------------------------------
@@ -301,7 +403,15 @@ module Vagrant
     def load!
       if !loaded?
         @loaded = true
-        self.class.check_virtualbox!
+
+        if !parent
+          # We only need to check the virtualbox version once, so do it on
+          # the parent most environment and then forget about it
+          logger.info("environment") { "Environment not loaded. Checking virtual box version..." }
+          self.class.check_virtualbox!
+        end
+
+        logger.info("environment") { "Loading configuration..." }
         load_config!
       end
 
@@ -327,9 +437,26 @@ module Vagrant
       @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
+
+      vagrantfile_name.each do |rootfile|
+        if !first_run && vm && box
+          # We load the box Vagrantfile
+          box_vagrantfile = box.directory.join(rootfile)
+          @config_loader.set(:box, box_vagrantfile) if box_vagrantfile.exist?
+        end
+
+        if !first_run && home_path
+          # Load the home Vagrantfile
+          home_vagrantfile = home_path.join(rootfile)
+          @config_loader.set(:home, home_vagrantfile) if home_vagrantfile.exist?
+        end
+
+        if root_path
+          # Load the Vagrantfile in this directory
+          root_vagrantfile = root_path.join(rootfile)
+          @config_loader.set(:root, root_vagrantfile) if root_vagrantfile.exist?
+        end
+      end
 
       # If this environment is representing a sub-VM, then we push that
       # proc on as the last configuration.
@@ -342,9 +469,6 @@ module Vagrant
       # value in the config ivar.
       @config = @config_loader.load(self)
 
-      # (re)load the logger
-      @logger = nil
-
       if first_run
         # After the first run we want to load the configuration again since
         # it can change due to box Vagrantfiles and home directory Vagrantfiles