vagrantup 1.0.7 → 1.1.0

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This middleware checks that the VM is created, and raises an exception
+      # if it is not, notifying the user that creation is required.
+      class CheckCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :not_created
+            raise Vagrant::Errors::VMNotCreatedError
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,6 @@
-module Vagrant
-  module Action
-    module VM
-      # Middleware which verifies that the VM has the proper guest additions
-      # installed and prints a warning if they're not detected or if the
-      # version does not match the installed VirtualBox version.
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class CheckGuestAdditions
         def initialize(app, env)
           @app = app
@@ -12,16 +9,25 @@ module Vagrant
         def call(env)
           # Use the raw interface for now, while the virtualbox gem
           # doesn't support guest properties (due to cross platform issues)
-          version = env[:vm].driver.read_guest_additions_version
+          version = env[:machine].provider.driver.read_guest_additions_version
           if !version
             env[:ui].warn I18n.t("vagrant.actions.vm.check_guest_additions.not_detected")
           else
-            # Strip the -OSE/_OSE off from the guest additions and the virtual box
-            # version since all the matters are that the version _numbers_ match up.
-            guest_version, vb_version = [version, env[:vm].driver.version].map do |v|
-              v.gsub(/[-_]ose/i, '')
+            # Read the versions
+            versions = [version, env[:machine].provider.driver.version]
+
+            # Strip of any -OSE or _OSE and read only the first two parts
+            # of the version such as "4.2" in "4.2.0"
+            versions.map! do |v|
+              v     = v.gsub(/[-_]ose/i, '')
+              match = /^(\d+\.\d+)\.(\d+)/.match(v)
+              v     = match[1] if match
+              v
             end
 
+            guest_version = versions[0]
+            vb_version    = versions[1]
+
             if guest_version != vb_version
               env[:ui].warn(I18n.t("vagrant.actions.vm.check_guest_additions.version_mismatch",
                                    :guest_version => version,
@@ -32,6 +38,7 @@ module Vagrant
           # Continue
           @app.call(env)
         end
+
       end
     end
   end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # This middleware checks that the VM is running, and raises an exception
+      # if it is not, notifying the user that the VM must be running.
+      class CheckRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id != :running
+            raise Vagrant::Errors::VMNotRunningError
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      # Checks that VirtualBox is installed and ready to be used.
+      class CheckVirtualbox
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # This verifies that VirtualBox is installed and the driver is
+          # ready to function. If not, then an exception will be raised
+          # which will break us out of execution of the middleware sequence.
+          Driver::Meta.new.verify!
+
+          # Carry on.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
-require 'fileutils'
+require "fileutils"
 
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       # Cleans up the VirtualBox machine folder for any ".xml-prev"
       # files which VirtualBox may have left over. This is a bug in
       # VirtualBox. As soon as this is fixed, this middleware can and
@@ -13,7 +13,7 @@ module Vagrant
         end
 
         def call(env)
-          clean_machine_folder(env[:vm].driver.read_machine_folder)
+          clean_machine_folder(env[:machine].provider.driver.read_machine_folder)
           @app.call(env)
         end
 

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

@@ -1,6 +1,6 @@
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class ClearForwardedPorts
         def initialize(app, env)
           @app = app
@@ -8,7 +8,7 @@ module Vagrant
 
         def call(env)
           env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
-          env[:vm].driver.clear_forwarded_ports
+          env[:machine].provider.driver.clear_forwarded_ports
 
           @app.call(env)
         end

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

@@ -1,6 +1,6 @@
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class ClearNetworkInterfaces
         def initialize(app, env)
           @app = app
@@ -21,7 +21,7 @@ module Vagrant
 
           # "Enable" all the adapters we setup.
           env[:ui].info I18n.t("vagrant.actions.vm.clear_network_interfaces.deleting")
-          env[:vm].driver.enable_adapters(adapters)
+          env[:machine].provider.driver.enable_adapters(adapters)
 
           @app.call(env)
         end

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

@@ -1,14 +1,13 @@
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class ClearSharedFolders
         def initialize(app, env)
           @app = app
-          @env = env
         end
 
         def call(env)
-          env[:vm].driver.clear_shared_folders
+          env[:machine].provider.driver.clear_shared_folders
 
           @app.call(env)
         end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Created
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is created.
+          env[:result] = env[:machine].state.id != :not_created
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,26 +1,26 @@
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class Customize
         def initialize(app, env)
           @app = app
         end
 
         def call(env)
-          customizations = env[:vm].config.vm.customizations
+          customizations = env[:machine].provider_config.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 = env[:machine].id if arg == :id
                 arg.to_s
               end
 
-              result = env[:vm].driver.execute_command(processed_command)
+              result = env[:machine].provider.driver.execute_command(processed_command)
               if result.exit_code != 0
-                raise Errors::VMCustomizationFailed, {
+                raise Vagrant::Errors::VMCustomizationFailed, {
                   :command => processed_command.inspect,
                   :error   => result.stderr
                 }

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

@@ -1,6 +1,6 @@
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class Destroy
         def initialize(app, env)
           @app = app
@@ -8,8 +8,8 @@ module Vagrant
 
         def call(env)
           env[:ui].info I18n.t("vagrant.actions.vm.destroy.destroying")
-          env[:vm].driver.delete
-          env[:vm].uuid = nil
+          env[:machine].provider.driver.delete
+          env[:machine].id = nil
 
           @app.call(env)
         end

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

@@ -0,0 +1,17 @@
+require "vagrant/action/builtin/confirm"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class DestroyConfirm < Vagrant::Action::Builtin::Confirm
+        def initialize(app, env)
+          force_key = :force_confirm_destroy
+          message   = I18n.t("vagrant.commands.destroy.confirmation",
+                             :name => env[:machine].name)
+
+          super(app, env, message, force_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class DestroyUnusedNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine].provider.driver.delete_unused_host_only_networks
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class DiscardState
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].provider.state.id == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.discard_state.discarding")
+            env[:machine].provider.driver.discard_saved_state
+          end
+
+           @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,20 +1,20 @@
-require 'fileutils'
+require "fileutils"
 
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class Export
         attr_reader :temp_dir
 
         def initialize(app, env)
           @app = app
-          @env = env
         end
 
         def call(env)
           @env = env
 
-          raise Errors::VMPowerOffToPackage if @env["vm"].state != :poweroff
+          raise Vagrant::Errors::VMPowerOffToPackage if \
+            @env[:machine].provider.state.id != :poweroff
 
           setup_temp_dir
           export
@@ -38,7 +38,7 @@ module Vagrant
 
         def export
           @env[:ui].info I18n.t("vagrant.actions.vm.export.exporting")
-          @env[:vm].driver.export(ovf_path) do |progress|
+          @env[:machine].provider.driver.export(ovf_path) do |progress|
             @env[:ui].clear_line
             @env[:ui].report_progress(progress.percent, 100, false)
           end

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ForcedHalt
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].state.id
+          if current_state == :running || current_state == :gurumeditation
+            env[:ui].info I18n.t("vagrant.actions.vm.halt.force")
+            env[:machine].provider.driver.halt
+          end
+
+          # Sleep for a second to verify that the VM properly
+          # cleans itself up. Silly VirtualBox.
+          sleep 1 if !env["vagrant.test"]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,10 @@
-module Vagrant
-  module Action
-    module VM
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
       class ForwardPorts
-        def initialize(app,env)
+        include Util::CompileForwardedPorts
+
+        def initialize(app, env)
           @app = app
         end
 
@@ -13,53 +15,32 @@ module Vagrant
           @env = env
 
           # Get the ports we're forwarding
-          ports = forward_port_definitions
+          env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
 
           # Warn if we're port forwarding to any privileged ports...
-          threshold_check(ports)
+          env[:forwarded_ports].each do |fp|
+            if fp.host_port <= 1024
+              env[:ui].warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
+              return
+            end
+          end
 
           env[:ui].info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
-          forward_ports(ports)
+          forward_ports
 
           @app.call(env)
         end
 
-        # 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
-
-          # Return the values, since the order doesn't really matter
-          guest_port_mapping.values
-        end
-
-        # 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
-        end
-
-        def forward_ports(mappings)
+        def forward_ports
           ports = []
 
-          interfaces = @env[:vm].driver.read_network_interfaces
+          interfaces = @env[:machine].provider.driver.read_network_interfaces
 
-          mappings.each do |options|
+          @env[:forwarded_ports].each do |fp|
             message_attributes = {
-              :guest_port => options[:guestport],
-              :host_port => options[:hostport],
-              :adapter => options[:adapter]
+              :adapter => fp.adapter,
+              :guest_port => fp.guest_port,
+              :host_port => fp.host_port
             }
 
             # Assuming the only reason to establish port forwarding is
@@ -71,19 +52,25 @@ module Vagrant
 
             # Port forwarding requires the network interface to be a NAT interface,
             # so verify that that is the case.
-            if interfaces[options[:adapter]][:type] != :nat
+            if interfaces[fp.adapter][:type] != :nat
               @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.non_nat",
                                     message_attributes))
               next
             end
 
             # Add the options to the ports array to send to the driver later
-            ports << options.merge(:name => options[:name], :adapter => options[:adapter])
+            ports << {
+              :adapter   => fp.adapter,
+              :guestport => fp.guest_port,
+              :hostport  => fp.host_port,
+              :name      => fp.id,
+              :protocol  => fp.protocol
+            }
           end
 
           if !ports.empty?
             # We only need to forward ports if there are any to forward
-            @env[:vm].driver.forward_ports(ports)
+            @env[:machine].provider.driver.forward_ports(ports)
           end
         end
       end