vagrantup 0.8.10 → 0.9.0

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

@@ -0,0 +1,85 @@
+module Vagrant
+  module Action
+    module VM
+      # Action that checks to make sure there are no forwarded port collisions,
+      # and raises an exception if there is.
+      class CheckPortCollisions
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # For the handlers...
+          @env = env
+
+          # Figure out how we handle port collisions. By default we error.
+          handler  = env[:port_collision_handler] || :error
+
+          # Read our forwarded ports, if we have any, to override what
+          # we have configured.
+          current = {}
+          env[:vm].driver.read_forwarded_ports.each do |nic, name, hostport, guestport|
+            current[name] = hostport.to_i
+          end
+
+          existing = env[:vm].driver.read_used_ports
+          env[:vm].config.vm.forwarded_ports.each do |options|
+            # Use the proper port, whether that be the configured port or the
+            # port that is currently on use of the VM.
+            hostport = options[:hostport].to_i
+            hostport = current[options[:name]] if current.has_key?(options[:name])
+
+            if existing.include?(hostport)
+              # We have a collision! Handle it
+              send("handle_#{handler}".to_sym, options, existing)
+            end
+          end
+
+          @app.call(env)
+        end
+
+        # Handles a port collision by raising an exception.
+        def handle_error(options, existing_ports)
+          raise Errors::ForwardPortCollisionResume
+        end
+
+        # Handles a port collision by attempting to fix it.
+        def handle_correct(options, existing_ports)
+          # We need to keep this for messaging purposes
+          original_hostport = options[:hostport]
+
+          if !options[:auto]
+            # Auto fixing is disabled for this port forward, so we
+            # must throw an error so the user can fix it.
+            raise Errors::ForwardPortCollision, :host_port => options[:hostport].to_s,
+                                                :guest_port => options[:guestport].to_s
+          end
+
+          # Get the auto port range and get rid of the used ports and
+          # ports which are being used in other forwards so we're just
+          # left with available ports.
+          range = @env[:vm].config.vm.auto_port_range.to_a
+          range -= @env[:vm].config.vm.forwarded_ports.collect { |opts| opts[:hostport].to_i }
+          range -= existing_ports
+
+          if range.empty?
+            raise Errors::ForwardPortAutolistEmpty, :vm_name => @env[:vm].name,
+                                                    :host_port => options[:hostport].to_s,
+                                                    :guest_port => options[:guestport].to_s
+          end
+
+          # Set the port up to be the first one and add that port to
+          # the used list.
+          options[:hostport] = range.shift
+          existing_ports << options[:hostport]
+
+          # Notify the user
+          @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.fixed_collision",
+                                :host_port => original_hostport.to_s,
+                                :guest_port => options[:guestport].to_s,
+                                :new_port => options[:hostport]))
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'fileutils'
 
 module Vagrant
-  class Action
+  module Action
     module VM
       # Cleans up the VirtualBox machine folder for any ".xml-prev"
       # files which VirtualBox may have left over. This is a bug in
@@ -13,12 +13,12 @@ module Vagrant
         end
 
         def call(env)
-          clean_machine_folder
+          clean_machine_folder(env[:vm].driver.read_machine_folder)
           @app.call(env)
         end
 
-        def clean_machine_folder
-          folder = File.join(VirtualBox::Global.global.system_properties.default_machine_folder, "*")
+        def clean_machine_folder(machine_folder)
+          folder = File.join(machine_folder, "*")
 
           # Small safeguard against potentially unwanted rm-rf, since the default
           # machine folder will typically always be greater than 10 characters long.

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class ClearForwardedPorts
         def initialize(app, env)
@@ -7,17 +7,9 @@ module Vagrant
         end
 
         def call(env)
-          proc = lambda do |vm|
-            env.ui.info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
+          env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
+          env[:vm].driver.clear_forwarded_ports
 
-            vm.network_adapters.each do |na|
-              na.nat_driver.forwarded_ports.dup.each do |fp|
-                fp.destroy
-              end
-            end
-          end
-
-          env["vm.modify"].call(proc)
           @app.call(env)
         end
       end

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

@@ -0,0 +1,31 @@
+module Vagrant
+  module Action
+    module VM
+      class ClearNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Create the adapters array to make all adapters nothing.
+          # We do adapters 2 to 8 because that is every built-in adapter
+          # excluding the NAT adapter on port 1 which Vagrant always
+          # expects to exist.
+          adapters = []
+          2.upto(8).each do |i|
+            adapters << {
+              :adapter => i,
+              :type    => :none
+            }
+          end
+
+          # "Enable" all the adapters we setup.
+          env[:ui].info I18n.t("vagrant.actions.vm.clear_network_interfaces.deleting")
+          env[:vm].driver.enable_adapters(adapters)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class ClearSharedFolders
         def initialize(app, env)
@@ -8,17 +8,8 @@ module Vagrant
         end
 
         def call(env)
-          proc = lambda do |vm|
-            if vm.shared_folders.length > 0
-              env.ui.info I18n.t("vagrant.actions.vm.clear_shared_folders.deleting")
+          env[:vm].driver.clear_shared_folders
 
-              vm.shared_folders.dup.each do |shared_folder|
-                shared_folder.destroy
-              end
-            end
-          end
-
-          env["vm.modify"].call(proc)
           @app.call(env)
         end
       end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Customize
         def initialize(app, env)
@@ -7,15 +7,25 @@ module Vagrant
         end
 
         def call(env)
-          if !env["config"].vm.proc_stack.empty?
-            # Create the proc which runs all of our procs
-            proc = lambda do |vm|
-              env.ui.info I18n.t("vagrant.actions.vm.customize.running")
-              env["config"].vm.run_procs!(vm)
-            end
+          customizations = env[:vm].config.vm.customizations
+          if !customizations.empty?
+            env[:ui].info I18n.t("vagrant.actions.vm.customize.running")
+
+            # Execute each customization command.
+            customizations.each do |command|
+              processed_command = command.collect do |arg|
+                arg = env[:vm].uuid if arg == :id
+                arg
+              end
 
-            # Add it to modify sequence
-            env["vm.modify"].call(proc)
+              result = env[:vm].driver.execute_command(processed_command)
+              if result.exit_code != 0
+                raise Errors::VMCustomizationFailed, {
+                  :command => processed_command.inspect,
+                  :error   => result.stderr
+                }
+              end
+            end
           end
 
           @app.call(env)

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Destroy
         def initialize(app, env)
@@ -7,9 +7,9 @@ module Vagrant
         end
 
         def call(env)
-          env.ui.info I18n.t("vagrant.actions.vm.destroy.destroying")
-          env["vm"].vm.destroy
-          env["vm"].vm = nil
+          env[:ui].info I18n.t("vagrant.actions.vm.destroy.destroying")
+          env[:vm].driver.delete
+          env[:vm].uuid = nil
 
           @app.call(env)
         end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       # Destroys the unused host only interfaces. This middleware cleans
       # up any created host only networks.
@@ -9,17 +9,7 @@ module Vagrant
         end
 
         def call(env)
-          # Destroy all the host only network adapters which are empty.
-          VirtualBox::Global.global(true).host.network_interfaces.each do |iface|
-            # We only care about host only interfaces
-            next if iface.interface_type != :host_only
-
-            # Destroy it if there is nothing attached
-            if iface.attached_vms.empty?
-              env.ui.info I18n.t("vagrant.actions.vm.destroy_network.destroying")
-              iface.destroy
-            end
-          end
+          env[:vm].driver.delete_unused_host_only_networks
 
           # Continue along
           @app.call(env)

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       # Discards the saved state of the VM if its saved. If its
       # not saved, does nothing.
@@ -9,9 +9,9 @@ module Vagrant
         end
 
         def call(env)
-          if env["vm"].created? && env["vm"].vm.saved?
-            env.ui.info I18n.t("vagrant.actions.vm.discard_state.discarding")
-            env["vm"].vm.discard_state
+          if env[:vm].state == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.discard_state.discarding")
+            env[:vm].driver.discard_saved_state
           end
 
           @app.call(env)

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

@@ -1,7 +1,7 @@
 require 'fileutils'
 
 module Vagrant
-  class Action
+  module Action
     module VM
       class Export
         attr_reader :temp_dir
@@ -14,7 +14,7 @@ module Vagrant
         def call(env)
           @env = env
 
-          raise Errors::VMPowerOffToPackage if !@env["vm"].vm.powered_off?
+          raise Errors::VMPowerOffToPackage if @env["vm"].state != :poweroff
 
           setup_temp_dir
           export
@@ -31,20 +31,25 @@ module Vagrant
         end
 
         def setup_temp_dir
-          @env.ui.info I18n.t("vagrant.actions.vm.export.create_dir")
-          @temp_dir = @env["export.temp_dir"] = @env.env.tmp_path.join(Time.now.to_i.to_s)
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.create_dir")
+          @temp_dir = @env["export.temp_dir"] = @env[:tmp_path].join(Time.now.to_i.to_s)
           FileUtils.mkpath(@env["export.temp_dir"])
         end
 
         def export
-          @env.ui.info I18n.t("vagrant.actions.vm.export.exporting")
-          @env["vm"].vm.export(ovf_path) do |progress|
-            @env.ui.report_progress(progress.percent, 100, false)
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.exporting")
+          @env[:vm].driver.export(ovf_path) do |progress|
+            @env[:ui].clear_line
+            @env[:ui].report_progress(progress.percent, 100, false)
           end
+
+          # Clear the line a final time so the next data can appear
+          # alone on the line.
+          @env[:ui].clear_line
         end
 
         def ovf_path
-          File.join(@env["export.temp_dir"], @env.env.config.vm.box_ovf)
+          File.join(@env["export.temp_dir"], "box.ovf")
         end
       end
     end

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

@@ -1,134 +1,87 @@
-require File.join(File.dirname(__FILE__), 'forward_ports_helpers')
-
 module Vagrant
-  class Action
+  module Action
     module VM
       class ForwardPorts
-        include ForwardPortsHelpers
-
         def initialize(app,env)
           @app = app
-          @env = env
-
-          threshold_check
-          external_collision_check
         end
 
         #--------------------------------------------------------------
-        # Prepare Helpers - These functions are not involved in actually
-        # executing the action
+        # Execution
         #--------------------------------------------------------------
+        def call(env)
+          @env = env
 
-        # This method checks for any forwarded ports on the host below
-        # 1024, which causes the forwarded ports to fail.
-        def threshold_check
-          @env.env.config.vm.forwarded_ports.each do |name, options|
-            if options[:hostport] <= 1024
-              @env.ui.warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
-              return
-            end
-          end
-        end
+          # Get the ports we're forwarding
+          ports = forward_port_definitions
 
-        # This method checks for any port collisions with any VMs
-        # which are already created (by Vagrant or otherwise).
-        # report the collisions detected or will attempt to fix them
-        # automatically if the port is configured to do so.
-        def external_collision_check
-          existing = used_ports
-          @env.env.config.vm.forwarded_ports.each do |name, options|
-            if existing.include?(options[:hostport].to_i)
-              handle_collision(name, options, existing)
-            end
-          end
-        end
+          # Warn if we're port forwarding to any privileged ports...
+          threshold_check(ports)
 
-        # Handles any collisions. This method will either attempt to
-        # fix the collision automatically or will raise an error if
-        # auto fixing is disabled.
-        def handle_collision(name, options, existing_ports)
-          if !options[:auto]
-            # Auto fixing is disabled for this port forward, so we
-            # must throw an error so the user can fix it.
-            raise Errors::ForwardPortCollision, :name => name,
-                                                :host_port => options[:hostport].to_s,
-                                                :guest_port => options[:guestport].to_s
-          end
+          env[:ui].info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
+          forward_ports(ports)
 
-          # Get the auto port range and get rid of the used ports and
-          # ports which are being used in other forwards so we're just
-          # left with available ports.
-          range = @env.env.config.vm.auto_port_range.to_a
-          range -= @env.env.config.vm.forwarded_ports.collect { |n, o| o[:hostport].to_i }
-          range -= existing_ports
+          @app.call(env)
+        end
 
-          if range.empty?
-            raise Errors::ForwardPortAutolistEmpty, :vm_name => @env["vm"].name,
-                                                    :name => name,
-                                                    :host_port => options[:hostport].to_s,
-                                                    :guest_port => options[:guestport].to_s
+        # This returns an array of forwarded ports with overrides properly
+        # squashed.
+        def forward_port_definitions
+          # Get all the port mappings in the order they're defined and
+          # organize them by their guestport, taking the "last one wins"
+          # approach.
+          guest_port_mapping = {}
+          @env[:vm].config.vm.forwarded_ports.each do |options|
+            guest_port_mapping[options[:guestport]] = options
           end
 
-          # Set the port up to be the first one and add that port to
-          # the used list.
-          options[:hostport] = range.shift
-          existing_ports << options[:hostport]
-
-          # Notify the user
-          @env.ui.info(I18n.t("vagrant.actions.vm.forward_ports.fixed_collision",
-                       :name => name,
-                       :new_port => options[:hostport]))
+          # Return the values, since the order doesn't really matter
+          guest_port_mapping.values
         end
 
-        #--------------------------------------------------------------
-        # Execution
-        #--------------------------------------------------------------
-        def call(env)
-          @env = env
-
-          proc = lambda do |vm|
-            env.ui.info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
-            forward_ports(vm)
+        # This method checks for any forwarded ports on the host below
+        # 1024, which causes the forwarded ports to fail.
+        def threshold_check(ports)
+          ports.each do |options|
+            if options[:hostport] <= 1024
+              @env[:ui].warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
+              return
+            end
           end
-
-          env["vm.modify"].call(proc)
-          @app.call(env)
         end
 
-        def forward_ports(vm)
-          @env.env.config.vm.forwarded_ports.each do |name, options|
-            adapter = options[:adapter]
+        def forward_ports(mappings)
+          ports = []
+
+          interfaces = @env[:vm].driver.read_network_interfaces
+
+          mappings.each do |options|
             message_attributes = {
-              :name => name,
               :guest_port => options[:guestport],
               :host_port => options[:hostport],
-              :adapter => adapter + 1
+              :adapter => options[:adapter]
             }
 
-            # Assuming the only reason to establish port forwarding is because the VM is using Virtualbox NAT networking.
-            # Host-only or Bridged networking don't require port-forwarding and establishing forwarded ports on these
-            # attachment types has uncertain behaviour.
-            if vm.network_adapters[adapter].attachment_type == :nat
-              @env.ui.info(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry", message_attributes))
-              forward_port(vm, name, options)
-            else
-              @env.ui.info(I18n.t("vagrant.actions.vm.forward_ports.non_nat", message_attributes))
+            # Assuming the only reason to establish port forwarding is
+            # because the VM is using Virtualbox NAT networking. Host-only
+            # bridged networking don't require port-forwarding and establishing
+            # forwarded ports on these attachment types has uncertain behaviour.
+            @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry",
+                                    message_attributes))
+
+            # Port forwarding requires the network interface to be a NAT interface,
+            # so verify that that is the case.
+            if interfaces[options[:adapter]][:type] != :nat
+              @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.non_nat",
+                                    message_attributes))
+              next
             end
-          end
-        end
 
-        #--------------------------------------------------------------
-        # General Helpers
-        #--------------------------------------------------------------
+            # Add the options to the ports array to send to the driver later
+            ports << options.merge(:name => options[:name], :adapter => options[:adapter])
+          end
 
-        # Forwards a port.
-        def forward_port(vm, name, options)
-          port = VirtualBox::NATForwardedPort.new
-          port.name = name
-          port.guestport = options[:guestport]
-          port.hostport = options[:hostport]
-          port.protocol = options[:protocol] || :tcp
-          vm.network_adapters[options[:adapter]].nat_driver.forwarded_ports << port
+          @env[:vm].driver.forward_ports(ports)
         end
       end
     end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Halt
         def initialize(app, env, options=nil)
@@ -8,12 +8,15 @@ module Vagrant
         end
 
         def call(env)
-          if env["vm"].created? && env["vm"].vm.running?
-            env["vm"].system.halt if !env["force"]
+          if env[:vm].state == :running
+            if !env["force"]
+              env[:ui].info I18n.t("vagrant.actions.vm.halt.graceful")
+              env[:vm].guest.halt
+            end
 
-            if env["vm"].vm.state(true) != :powered_off
-              env.ui.info I18n.t("vagrant.actions.vm.halt.force")
-              env["vm"].vm.stop
+            if env[:vm].state != :poweroff
+              env[:ui].info I18n.t("vagrant.actions.vm.halt.force")
+              env[:vm].driver.halt
             end
 
             # Sleep for a second to verify that the VM properly

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class HostName
         def initialize(app, env)
@@ -9,10 +9,10 @@ module Vagrant
         def call(env)
           @app.call(env)
 
-          host_name = env["config"].vm.host_name
+          host_name = env[:vm].config.vm.host_name
           if !host_name.nil?
-            env.ui.info I18n.t("vagrant.actions.vm.host_name.setting")
-            env["vm"].system.change_host_name(host_name)
+            env[:ui].info I18n.t("vagrant.actions.vm.host_name.setting")
+            env[:vm].guest.change_host_name(host_name)
           end
         end
       end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Import
         def initialize(app, env)
@@ -7,31 +7,40 @@ module Vagrant
         end
 
         def call(env)
-          env.ui.info I18n.t("vagrant.actions.vm.import.importing", :name => env.env.box.name)
+          env[:ui].info I18n.t("vagrant.actions.vm.import.importing", :name => env[:vm].box.name)
 
           # Import the virtual machine
-          env.env.vm.vm = VirtualBox::VM.import(env.env.box.ovf_file.to_s) do |progress|
-            env.ui.clear_line
-            env.ui.report_progress(progress.percent, 100, false)
+          name = File.basename(env[:vm].env.cwd) + "_#{Time.now.to_i}"
+          ovf_file = env[:vm].box.directory.join("box.ovf").to_s
+          env[:vm].uuid = env[:vm].driver.import(ovf_file, name) do |progress|
+            env[:ui].clear_line
+            env[:ui].report_progress(progress, 100, false)
           end
 
           # Clear the line one last time since the progress meter doesn't disappear
           # immediately.
-          env.ui.clear_line
+          env[:ui].clear_line
+
+          # If we got interrupted, then the import could have been
+          # interrupted and its not a big deal. Just return out.
+          return if env[:interrupted]
 
           # Flag as erroneous and return if import failed
-          raise Errors::VMImportFailure if !env["vm"].vm
+          raise Errors::VMImportFailure if !env[:vm].uuid
 
           # Import completed successfully. Continue the chain
           @app.call(env)
         end
 
         def recover(env)
-          if env["vm"].created?
+          if env[:vm].created?
             return if env["vagrant.error"].is_a?(Errors::VagrantError)
 
-            # Interrupted, destroy the VM
-            env["actions"].run(:destroy)
+            # Interrupted, destroy the VM. We note that we don't want to
+            # validate the configuration here.
+            destroy_env = env.clone
+            destroy_env[:validate] = false
+            env[:action_runner].run(:destroy, destroy_env)
           end
         end
       end