vagrant 0.8.10 → 0.9.0

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

@@ -1,7 +1,5 @@
-require File.expand_path("../nfs_helpers", __FILE__)
-
 module Vagrant
-  class Action
+  module Action
     module VM
       # Enables NFS based shared folders. `nfsd` must already be installed
       # on the host machine, and NFS client must already be installed on
@@ -16,8 +14,6 @@ module Vagrant
       #      folder.
       #
       class NFS
-        include NFSHelpers
-
         def initialize(app,env)
           @app = app
           @env = env
@@ -32,7 +28,6 @@ module Vagrant
 
           if !folders.empty?
             prepare_folders
-            clear_nfs_exports(env)
             export_folders
           end
 
@@ -42,7 +37,12 @@ module Vagrant
         end
 
         def recover(env)
-          clear_nfs_exports(env) if env["vm"].created?
+          # Ignore any VagrantErrors, because they were expected and
+          # will cause the VM to stick around.
+          return if env["vagrant.error"].is_a?(Errors::VagrantError)
+
+          # Otherwise, clear the NFS exports.
+          clear_nfs_exports(env)
         end
 
         # Returns the folders which are to be synced via NFS.
@@ -55,14 +55,14 @@ module Vagrant
         # task.
         def extract_folders
           # Load the NFS enabled shared folders
-          @folders = @env["config"].vm.shared_folders.inject({}) do |acc, data|
+          @folders = @env[:vm].config.vm.shared_folders.inject({}) do |acc, data|
             key, opts = data
 
             if opts[:nfs]
               # Duplicate the options, set the hostpath, and set disabled on the original
               # options so the ShareFolders middleware doesn't try to mount it.
               acc[key] = opts.dup
-              acc[key][:hostpath] = File.expand_path(opts[:hostpath], @env.env.root_path)
+              acc[key][:hostpath] = File.expand_path(opts[:hostpath], @env[:root_path])
               opts[:disabled] = true
             end
 
@@ -91,7 +91,7 @@ module Vagrant
 
           # The options on the hash get priority, then the default
           # values
-          value = opts.has_key?(key) ? opts[key] : @env["config"].nfs.send(key)
+          value = opts.has_key?(key) ? opts[key] : @env[:vm].config.nfs.send(key)
           return value if value != :auto
 
           # Get UID/GID from folder if we've made it this far
@@ -104,31 +104,40 @@ module Vagrant
         # involves adding a line to `/etc/exports` for this VM, but it is
         # up to the host class to define the specific behavior.
         def export_folders
-          @env.ui.info I18n.t("vagrant.actions.vm.nfs.exporting")
-
-          @env["host"].nfs_export(guest_ip, folders)
+          @env[:ui].info I18n.t("vagrant.actions.vm.nfs.exporting")
+          @env[:host].nfs_export(@env[:vm].uuid, guest_ip, folders)
         end
 
         # Uses the system class to mount the NFS folders.
         def mount_folders
-          @env.ui.info I18n.t("vagrant.actions.vm.nfs.mounting")
+          @env[:ui].info I18n.t("vagrant.actions.vm.nfs.mounting")
 
           # Only mount the folders which have a guest path specified
-          am_folders = folders.select { |name, folder| folder[:guestpath] }
-          am_folders = Hash[*am_folders.flatten] if am_folders.is_a?(Array)
-          @env["vm"].system.mount_nfs(host_ip, Hash[am_folders])
+          mount_folders = {}
+          folders.each do |name, opts|
+            if opts[:guestpath]
+              mount_folders[name] = opts.dup
+            end
+          end
+
+          @env[:vm].guest.mount_nfs(host_ip, mount_folders)
         end
 
         # Returns the IP address of the first host only network adapter
         #
         # @return [String]
         def host_ip
-          interface = @env["vm"].vm.network_adapters.find do |adapter|
-            adapter.host_interface_object
+          @env[:vm].driver.read_network_interfaces.each do |adapter, opts|
+            if opts[:type] == :hostonly
+              @env[:vm].driver.read_host_only_interfaces.each do |interface|
+                if interface[:name] == opts[:hostonly]
+                  return interface[:ip]
+                end
+              end
+            end
           end
 
-          return nil if !interface
-          interface.host_interface_object.ip_address
+          nil
         end
 
         # Returns the IP address of the guest by looking at the first
@@ -136,12 +145,18 @@ module Vagrant
         #
         # @return [String]
         def guest_ip
-          @env["config"].vm.network_options[1][:ip]
+          @env[:vm].config.vm.networks.each do |type, args|
+            if type == :hostonly && args[0].is_a?(String)
+              return args[0]
+            end
+          end
+
+          nil
         end
 
         # Checks if there are any NFS enabled shared folders.
         def nfs_enabled?
-          @env["config"].vm.shared_folders.each do |key, opts|
+          @env[:vm].config.vm.shared_folders.each do |key, opts|
             return true if opts[:nfs]
           end
 
@@ -150,9 +165,9 @@ module Vagrant
 
         # Verifies that the host is set and supports NFS.
         def verify_settings
-          raise Errors::NFSHostRequired if @env["host"].nil?
-          raise Errors::NFSNotSupported if !@env["host"].nfs?
-          raise Errors::NFSNoHostNetwork if @env["config"].vm.network_options.empty?
+          raise Errors::NFSHostRequired if @env[:host].nil?
+          raise Errors::NFSNotSupported if !@env[:host].nfs?
+          raise Errors::NFSNoHostNetwork if !guest_ip
         end
       end
     end

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

@@ -1,7 +1,7 @@
 require 'vagrant/action/general/package'
 
 module Vagrant
-  class Action
+  module Action
     module VM
       # A subclass of {General::Package} which simply makes sure that
       # the package directory is set to the directory which the VM

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

@@ -1,9 +1,12 @@
+require 'vagrant/util/template_renderer'
+
 module Vagrant
-  class Action
+  module Action
     module VM
       # Puts a generated Vagrantfile into the package directory so that
       # it can be included in the package.
       class PackageVagrantfile
+        # For TemplateRenderer
         include Util
 
         def initialize(app, env)
@@ -23,7 +26,7 @@ module Vagrant
         def create_vagrantfile
           File.open(File.join(@env["export.temp_dir"], "Vagrantfile"), "w") do |f|
             f.write(TemplateRenderer.render("package_Vagrantfile", {
-              :base_mac => @env["vm"].vm.network_adapters.first.mac_address
+              :base_mac => @env["vm"].driver.read_mac_address
             }))
           end
         end

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

@@ -1,32 +1,61 @@
+require "log4r"
+
 module Vagrant
-  class Action
+  module Action
     module VM
       class Provision
         def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::provision")
           @app = app
-          @env = env
-          @env["provision.enabled"] = true if !@env.has_key?("provision.enabled")
+
+          env["provision.enabled"] = true if !env.has_key?("provision.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 }
+          @env = env
+
+          provisioners = nil
+
+          # We set this here so that even if this value is changed in the future,
+          # it stays constant to what we expect here in this moment.
+          enabled = env["provision.enabled"]
+          if enabled
+            # 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 }
+          end
 
           @app.call(env)
 
-          # 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!
+          if enabled
+            # 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
         end
 
         def enabled_provisioners
-          @env["config"].vm.provisioners.map do |provisioner|
-            provisioner.provisioner.new(@env, provisioner.config)
+          enabled = []
+          @env[:vm].config.vm.provisioners.each do |provisioner|
+            if @env["provision.types"]
+              # If we've specified types of provisioners to enable, then we
+              # only use those provisioners, and skip any that we haven't
+              # specified.
+              if !@env["provision.types"].include?(provisioner.shortcut.to_s)
+                @logger.debug("Skipping provisioner: #{provisioner.shortcut}")
+                next
+              end
+            end
+
+            enabled << provisioner.provisioner.new(@env, provisioner.config)
           end
+
+          # Return the enable provisioners
+          enabled
         end
       end
     end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class ProvisionerCleanup
         def initialize(app, env)
@@ -16,7 +16,7 @@ module Vagrant
         end
 
         def enabled_provisioners
-          @env["config"].vm.provisioners.map do |provisioner|
+          @env[:vm].config.vm.provisioners.map do |provisioner|
             provisioner.provisioner.new(@env, provisioner.config)
           end
         end

data/lib/vagrant/action/vm/{clear_nfs_exports.rb → prune_nfs_exports.rb}

@@ -1,17 +1,17 @@
-require File.expand_path("../nfs_helpers", __FILE__)
-
 module Vagrant
-  class Action
+  module Action
     module VM
-      class ClearNFSExports
-        include NFSHelpers
-
+      class PruneNFSExports
         def initialize(app, env)
           @app = app
         end
 
         def call(env)
-          clear_nfs_exports(env)
+          if env[:host]
+            valid_ids = env[:vm].driver.read_vms
+            env[:host].nfs_prune(valid_ids)
+          end
+
           @app.call(env)
         end
       end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Resume
         def initialize(app, env)
@@ -7,9 +7,9 @@ module Vagrant
         end
 
         def call(env)
-          if env["vm"].vm.saved?
-            env.ui.info I18n.t("vagrant.actions.vm.resume.resuming")
-            env["actions"].run(Boot)
+          if env[:vm].state == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:action_runner].run(Boot, env)
           end
 
           @app.call(env)

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

@@ -0,0 +1,54 @@
+require 'pathname'
+
+module Vagrant
+  module Action
+    module VM
+      # Sets up the mapping of files to copy into the package and verifies
+      # that the files can be properly copied.
+      class SetupPackageFiles
+        def initialize(app, env)
+          @app = app
+
+          env["package.include"] ||= []
+          env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Errors::PackageIncludeMissing, :file => from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,20 @@
+require 'pathname'
+
+require 'log4r'
+
 module Vagrant
-  class Action
+  module Action
     module VM
       class ShareFolders
         def initialize(app, env)
-          @app = app
-          @env = env
+          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
+          @app    = app
         end
 
         def call(env)
           @env = env
 
+          prepare_folders
           create_metadata
 
           @app.call(env)
@@ -20,7 +25,7 @@ module Vagrant
         # This method returns an actual list of VirtualBox shared
         # folders to create and their proper path.
         def shared_folders
-          @env.env.config.vm.shared_folders.inject({}) do |acc, data|
+          @env[:vm].config.vm.shared_folders.inject({}) do |acc, data|
             key, value = data
 
             next acc if value[:disabled]
@@ -32,54 +37,73 @@ module Vagrant
           end
         end
 
-        def create_metadata
-          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)
-              vm.shared_folders << folder
+        # Prepares the shared folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          shared_folders.each do |name, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            if !hostpath.directory? && options[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                hostpath.mkpath
+              rescue Errno::EACCES
+                raise Errors::SharedFolderCreateFailed, :path => hostpath.to_s
+              end
             end
           end
+        end
 
-          @env["vm.modify"].call(proc)
+        def create_metadata
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+          folders = []
+          shared_folders.each do |name, data|
+            folders << {
+              :name => name,
+              :hostpath => File.expand_path(data[:hostpath], @env[:root_path])
+            }
+          end
+
+          @env[:vm].driver.share_folders(folders)
         end
 
         def mount_shared_folders
-          @env.ui.info I18n.t("vagrant.actions.vm.share_folders.mounting")
-
-          @env["vm"].ssh.execute do |ssh|
-            # short guestpaths first, so we don't step on ourselves
-            folders = shared_folders.sort_by do |name, data|
-              if data[:guestpath]
-                data[:guestpath].length
-              else
-                # A long enough path to just do this at the end.
-                10000
-              end
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
+
+          # short guestpaths first, so we don't step on ourselves
+          folders = shared_folders.sort_by do |name, data|
+            if data[:guestpath]
+              data[:guestpath].length
+            else
+              # A long enough path to just do this at the end.
+              10000
             end
+          end
 
-            # Go through each folder and mount
-            folders.each do |name, data|
-              if data[:guestpath]
-                # Guest path specified, so mount the folder to specified point
-                @env.ui.info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+          # Go through each folder and mount
+          folders.each do |name, data|
+            if data[:guestpath]
+              # Guest path specified, so mount the folder to specified point
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
                                     :name => name,
                                     :guest_path => data[:guestpath]))
 
-                # Calculate the owner and group
-                owner = data[:owner] || @env["config"].ssh.username
-                group = data[:group] || @env["config"].ssh.username
+              # Dup the data so we can pass it to the guest API
+              data = data.dup
 
-                # 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",
+              # Calculate the owner and group
+              data[:owner] ||= @env[:vm].config.ssh.username
+              data[:group] ||= @env[:vm].config.ssh.username
+
+              # Mount the actual folder
+              @env[:vm].guest.mount_shared_folder(name, data[:guestpath], data)
+            else
+              # If no guest path is specified, then automounting is disabled
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
                                     :name => name))
-              end
             end
           end
         end