vagrantup 1.0.7 → 1.1.0

data/{lib/vagrant/action/vm → plugins/providers/virtualbox/action}/package.rb

@@ -1,12 +1,9 @@
 require 'vagrant/action/general/package'
 
-module Vagrant
-  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
-      # was exported to.
-      class Package < General::Package
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Package < Vagrant::Action::General::Package
         # Doing this so that we can test that the parent is properly
         # called in the unit tests.
         alias_method :general_call, :call

data/{lib/vagrant/action/vm → plugins/providers/virtualbox/action}/package_vagrantfile.rb

@@ -1,17 +1,14 @@
 require 'vagrant/util/template_renderer'
 
-module Vagrant
-  module Action
-    module VM
-      # Puts a generated Vagrantfile into the package directory so that
-      # it can be included in the package.
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class PackageVagrantfile
         # For TemplateRenderer
-        include Util
+        include Vagrant::Util
 
         def initialize(app, env)
           @app = app
-          @env = env
         end
 
         def call(env)
@@ -26,7 +23,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"].driver.read_mac_address
+              :base_mac => @env[:machine].provider.driver.read_mac_address
             }))
           end
         end

data/plugins/providers/virtualbox/action/prepare_forwarded_port_collision_params.rb

@@ -0,0 +1,35 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PrepareForwardedPortCollisionParams
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Get the forwarded ports used by other virtual machines and
+          # consider those in use as well.
+          env[:port_collision_extra_in_use] = env[:machine].provider.driver.read_used_ports
+
+          # Build the remap for any existing collision detections
+          remap = {}
+          env[:port_collision_remap] = remap
+          env[:machine].provider.driver.read_forwarded_ports.each do |_nic, name, hostport, _guestport|
+            env[:machine].config.vm.networks.each do |type, options|
+              next if type != :forwarded_port
+
+              # If the ID matches the name of the forwarded port, then
+              # remap.
+              if options[:id] == name
+                remap[name] = hostport
+                break
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/prepare_nfs_settings.rb

@@ -0,0 +1,51 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PrepareNFSSettings
+        def initialize(app,env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          env[:nfs_host_ip]    = read_host_ip(env[:machine])
+          env[:nfs_machine_ip] = read_machine_ip(env[:machine])
+        end
+
+        # Returns the IP address of the first host only network adapter
+        #
+        # @param [Machine] machine
+        # @return [String]
+        def read_host_ip(machine)
+          machine.provider.driver.read_network_interfaces.each do |adapter, opts|
+            if opts[:type] == :hostonly
+              machine.provider.driver.read_host_only_interfaces.each do |interface|
+                if interface[:name] == opts[:hostonly]
+                  return interface[:ip]
+                end
+              end
+            end
+          end
+
+          nil
+        end
+
+        # Returns the IP address of the guest by looking at the first
+        # enabled host only network.
+        #
+        # @return [String]
+        def read_machine_ip(machine)
+          machine.config.vm.networks.each do |type, options|
+            if type == :private_network && options[:ip].is_a?(String)
+              return options[:ip]
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/{lib/vagrant/action/vm → plugins/providers/virtualbox/action}/prune_nfs_exports.rb

@@ -1,6 +1,6 @@
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class PruneNFSExports
         def initialize(app, env)
           @app = app
@@ -8,8 +8,8 @@ module Vagrant
 
         def call(env)
           if env[:host]
-            valid_ids = env[:vm].driver.read_vms
-            env[:host].nfs_prune(valid_ids)
+            vms = env[:machine].provider.driver.read_vms
+            env[:host].nfs_prune(vms.values)
           end
 
           @app.call(env)

data/plugins/providers/virtualbox/action/resume.rb

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].provider.state.id
+
+          if current_state == :paused
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.unpausing")
+            env[:machine].provider.driver.resume
+          elsif current_state == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:action_runner].run(Boot, env)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/{lib/vagrant/action/vm → plugins/providers/virtualbox/action}/sane_defaults.rb

@@ -1,11 +1,8 @@
 require "log4r"
 
-module Vagrant
-  module Action
-    module VM
-      # This middleware enforces some sane defaults on the virtualbox
-      # VM which help with performance, stability, and in some cases
-      # behavior.
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class SaneDefaults
         def initialize(app, env)
           @logger = Log4r::Logger.new("vagrant::action::vm::sanedefaults")
@@ -22,39 +19,27 @@ module Vagrant
           # errors. The Host IO cache vastly improves disk IO performance
           # for VMs.
           command = [
-            "storagectl", env[:vm].uuid,
+            "storagectl", env[:machine].id,
             "--name", "SATA Controller",
             "--hostiocache", "on"
           ]
           attempt_and_log(command, "Enabling the Host I/O cache on the SATA controller...")
 
-          enable_dns_proxy = true
-          begin
-            contents = File.read("/etc/resolv.conf")
+          if env[:machine].provider_config.auto_nat_dns_proxy
+            @logger.info("Automatically figuring out whether to enable/disable NAT DNS proxy...")
 
-            if contents =~ /^nameserver 127\.0\.(0|1)\.1$/
-              # The use of both natdnsproxy and natdnshostresolver break on
-              # Ubuntu 12.04 that uses resolvconf with localhost. When used
-              # VirtualBox will give the client dns server 10.0.2.3, while
-              # not binding to that address itself. Therefore disable this
-              # feature if host uses the resolvconf server 127.0.0.1
-              @logger.info("Disabling DNS proxy since resolv.conf contains 127.0.0.1")
-              enable_dns_proxy = false
+            # Enable/disable the NAT DNS proxy as necessary
+            if enable_dns_proxy?
+              command = ["modifyvm", env[:machine].id, "--natdnsproxy1", "on"]
+              attempt_and_log(command, "Enable the NAT DNS proxy on adapter 1...")
+            else
+              command = [ "modifyvm", env[:machine].id, "--natdnsproxy1", "off" ]
+              attempt_and_log(command, "Disable the NAT DNS proxy on adapter 1...")
+              command = [ "modifyvm", env[:machine].id, "--natdnshostresolver1", "off" ]
+              attempt_and_log(command, "Disable the NAT DNS resolver on adapter 1...")
             end
-          rescue Errno::ENOENT; end
-
-          # Enable/disable the NAT DNS proxy as necessary
-          if enable_dns_proxy
-            command = [
-              "modifyvm", env[:vm].uuid,
-              "--natdnsproxy1", "on"
-            ]
-            attempt_and_log(command, "Enable the NAT DNS proxy on adapter 1...")
           else
-            command = [ "modifyvm", env[:vm].uuid, "--natdnsproxy1", "off" ]
-            attempt_and_log(command, "Disable the NAT DNS proxy on adapter 1...")
-            command = [ "modifyvm", env[:vm].uuid, "--natdnshostresolver1", "off" ]
-            attempt_and_log(command, "Disable the NAT DNS resolver on adapter 1...")
+            @logger.info("NOT trying to automatically manage NAT DNS proxy.")
           end
 
           @app.call(env)
@@ -69,9 +54,33 @@ module Vagrant
         # @param [Array] command Command to run
         # @param [String] log Log message to write.
         def attempt_and_log(command, log)
-          result = @env[:vm].driver.execute_command(command)
+          result = @env[:machine].provider.driver.execute_command(command)
           @logger.info("#{log} (exit status = #{result.exit_code})")
         end
+
+        # This uses some heuristics to determine if the NAT DNS proxy should
+        # be enabled or disabled. See the comments within the function body
+        # itself to see the checks it does.
+        #
+        # @return [Boolean]
+        def enable_dns_proxy?
+          begin
+            contents = File.read("/etc/resolv.conf")
+
+            if contents =~ /^nameserver 127\.0\.(0|1)\.1$/
+              # The use of both natdnsproxy and natdnshostresolver break on
+              # Ubuntu 12.04 and 12.10 that uses resolvconf with localhost. When used
+              # VirtualBox will give the client dns server 10.0.2.3, while
+              # not binding to that address itself. Therefore disable this
+              # feature if host uses the resolvconf server 127.0.0.1 or
+              # 127.0.1.1
+              @logger.info("Disabling DNS proxy since resolv.conf contains 127.0.0.1 or 127.0.1.1")
+              return false
+            end
+          rescue Errno::ENOENT; end
+
+          return true
+        end
       end
     end
   end

data/plugins/providers/virtualbox/action/set_name.rb

@@ -0,0 +1,40 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class SetName
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::setname")
+          @app = app
+        end
+
+        def call(env)
+          name = env[:machine].provider_config.name
+
+          # If no name was manually set, then use a default
+          if !name
+            prefix = env[:root_path].basename.to_s
+            prefix.gsub!(/[^-a-z0-9_]/i, "")
+            name = prefix + "_#{Time.now.to_i}"
+          end
+
+          # Verify the name is not taken
+          vms = env[:machine].provider.driver.read_vms
+          raise Vagrant::Errors::VMNameExists, :name => name if \
+            vms.has_key?(name) && vms[name] != env[:machine].id
+
+          if vms.has_key?(name)
+            @logger.info("Not setting the name because our name is already set.")
+          else
+            @logger.info("Setting the name of the VM: #{name}")
+            env[:ui].info(I18n.t("vagrant.actions.vm.set_name.setting_name"))
+            env[:machine].provider.driver.set_name(name)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/{lib/vagrant/action/vm → plugins/providers/virtualbox/action}/setup_package_files.rb

@@ -1,10 +1,6 @@
-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.
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class SetupPackageFiles
         def initialize(app, env)
           @app = app
@@ -40,7 +36,8 @@ module Vagrant
 
           # Verify the mapping
           files.each do |from, _|
-            raise Errors::PackageIncludeMissing, :file => from if !File.exist?(from)
+            raise Vagrant::Errors::PackageIncludeMissing,
+              :file => from if !File.exist?(from)
           end
 
           # Save the mapping

data/{lib/vagrant/action/vm → plugins/providers/virtualbox/action}/share_folders.rb

@@ -1,10 +1,10 @@
-require 'pathname'
+require "pathname"
 
-require 'log4r'
+require "log4r"
 
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class ShareFolders
         def initialize(app, env)
           @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
@@ -25,22 +25,21 @@ module Vagrant
         # This method returns an actual list of VirtualBox shared
         # folders to create and their proper path.
         def shared_folders
-          @env[:vm].config.vm.shared_folders.inject({}) do |acc, data|
-            key, value = data
+          {}.tap do |result|
+            @env[:machine].config.vm.synced_folders.each do |id, data|
+              # Ignore NFS shared folders
+              next if data[:nfs]
 
-            next acc if value[:disabled]
-
-            # This to prevent overwriting the actual shared folders data
-            value = value.dup
-            acc[key] = value
-            acc
+              # This to prevent overwriting the actual shared folders data
+              result[id] = data.dup
+            end
           end
         end
 
         # Prepares the shared folders by verifying they exist and creating them
         # if they don't.
         def prepare_folders
-          shared_folders.each do |name, options|
+          shared_folders.each do |id, options|
             hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
 
             if !hostpath.directory? && options[:create]
@@ -50,7 +49,8 @@ module Vagrant
               begin
                 hostpath.mkpath
               rescue Errno::EACCES
-                raise Errors::SharedFolderCreateFailed, :path => hostpath.to_s
+                raise Vagrant::Errors::SharedFolderCreateFailed,
+                  :path => hostpath.to_s
               end
             end
           end
@@ -60,22 +60,22 @@ module Vagrant
           @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
 
           folders = []
-          shared_folders.each do |name, data|
+          shared_folders.each do |id, data|
             folders << {
-              :name => name,
+              :name => id,
               :hostpath => File.expand_path(data[:hostpath], @env[:root_path]),
               :transient => data[:transient]
             }
           end
 
-          @env[:vm].driver.share_folders(folders)
+          @env[:machine].provider.driver.share_folders(folders)
         end
 
         def mount_shared_folders
           @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|
+          folders = shared_folders.sort_by do |id, data|
             if data[:guestpath]
               data[:guestpath].length
             else
@@ -85,26 +85,25 @@ module Vagrant
           end
 
           # Go through each folder and mount
-          folders.each do |name, data|
+          folders.each do |id, 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]))
 
               # Dup the data so we can pass it to the guest API
               data = data.dup
 
               # Calculate the owner and group
-              data[:owner] ||= @env[:vm].config.ssh.username
-              data[:group] ||= @env[:vm].config.ssh.username
+              data[:owner] ||= @env[:machine].config.ssh.username
+              data[:group] ||= @env[:machine].config.ssh.username
 
               # Mount the actual folder
-              @env[:vm].guest.mount_shared_folder(name, data[:guestpath], data)
+              @env[:machine].guest.mount_shared_folder(id, 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))
+                                    :host_path => data[:hostpath]))
             end
           end
         end