boxcar 0.10005.1

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

@@ -0,0 +1,18 @@
+module Vagrant
+  module Action
+    module VM
+      class ClearForwardedPorts
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
+          env[:vm].driver.clear_forwarded_ports
+
+          @app.call(env)
+        end
+      end
+    end
+  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

@@ -0,0 +1,18 @@
+module Vagrant
+  module Action
+    module VM
+      class ClearSharedFolders
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          env[:vm].driver.clear_shared_folders
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Vagrant
+  module Action
+    module VM
+      class Customize
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          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.to_s
+              end
+
+              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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'log4r'
+
+module Vagrant
+  module Action
+    module VM
+      class DefaultName
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::defaultname")
+          @app = app
+        end
+
+        def call(env)
+          @logger.info("Setting the default name of the VM")
+          name = env[:root_path].basename.to_s + "_#{Time.now.to_i}"
+          env[:vm].driver.set_name(name)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+module Vagrant
+  module Action
+    module VM
+      # Destroys the unused host only interfaces. This middleware cleans
+      # up any created host only networks.
+      class DestroyUnusedNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:vm].driver.delete_unused_host_only_networks
+
+          # Continue along
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Vagrant
+  module Action
+    module VM
+      # Discards the saved state of the VM if its saved. If its
+      # not saved, does nothing.
+      class DiscardState
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'fileutils'
+
+module Vagrant
+  module Action
+    module VM
+      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
+
+          setup_temp_dir
+          export
+
+          @app.call(env)
+
+          recover(env) # called to cleanup temp directory
+        end
+
+        def recover(env)
+          if temp_dir && File.exist?(temp_dir)
+            FileUtils.rm_rf(temp_dir)
+          end
+        end
+
+        def setup_temp_dir
+          @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].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"], "box.ovf")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Vagrant
+  module Action
+    module VM
+      class ForwardPorts
+        def initialize(app,env)
+          @app = app
+        end
+
+        #--------------------------------------------------------------
+        # Execution
+        #--------------------------------------------------------------
+        def call(env)
+          @env = env
+
+          # Get the ports we're forwarding
+          ports = forward_port_definitions
+
+          # Warn if we're port forwarding to any privileged ports...
+          threshold_check(ports)
+
+          env[:ui].info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
+          forward_ports(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)
+          ports = []
+
+          interfaces = @env[:vm].driver.read_network_interfaces
+
+          mappings.each do |options|
+            message_attributes = {
+              :guest_port => options[:guestport],
+              :host_port => options[:hostport],
+              :adapter => options[:adapter]
+            }
+
+            # 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
+
+            # Add the options to the ports array to send to the driver later
+            ports << options.merge(:name => options[:name], :adapter => options[:adapter])
+          end
+
+          if !ports.empty?
+            # We only need to forward ports if there are any to forward
+            @env[:vm].driver.forward_ports(ports)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Vagrant
+  module Action
+    module VM
+      class Halt
+        def initialize(app, env, options=nil)
+          @app = app
+          env.merge!(options || {})
+        end
+
+        def call(env)
+          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].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
+            # cleans itself up
+            sleep 1 if !env["vagrant.test"]
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Vagrant
+  module Action
+    module VM
+      class HostName
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+
+          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].guest.change_host_name(host_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Vagrant
+  module Action
+    module VM
+      class Import
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.import.importing", :name => env[:vm].box.name)
+
+          # Import the virtual machine
+          ovf_file = env[:vm].box.directory.join("box.ovf").to_s
+          env[:vm].uuid = env[:vm].driver.import(ovf_file) 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
+
+          # 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].uuid
+
+          # Import completed successfully. Continue the chain
+          @app.call(env)
+        end
+
+        def recover(env)
+          if env[:vm].created?
+            return if env["vagrant.error"].is_a?(Errors::VagrantError)
+
+            # 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
+    end
+  end
+end