rvagrant 0.8.7.dev

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

@@ -0,0 +1,27 @@
+module Vagrant
+  class Action
+    module VM
+      class ClearSharedFolders
+        def initialize(app, env)
+          @app = app
+          @env = env
+        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")
+
+              vm.shared_folders.dup.each do |shared_folder|
+                shared_folder.destroy
+              end
+            end
+          end
+
+          env["vm.modify"].call(proc)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Vagrant
+  class Action
+    module VM
+      class Customize
+        def initialize(app, env)
+          @app = app
+        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
+
+            # Add it to modify sequence
+            env["vm.modify"].call(proc)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Vagrant
+  class 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"].vm.destroy
+          env["vm"].vm = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Vagrant
+  class 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)
+          # 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
+
+          # Continue along
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Vagrant
+  class 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"].created? && env["vm"].vm.saved?
+            env.ui.info I18n.t("vagrant.actions.vm.discard_state.discarding")
+            env["vm"].vm.discard_state
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'fileutils'
+
+module Vagrant
+  class 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"].vm.powered_off?
+
+          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.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)
+          end
+        end
+
+        def ovf_path
+          File.join(@env["export.temp_dir"], @env.env.config.vm.box_ovf)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+require File.join(File.dirname(__FILE__), 'forward_ports_helpers')
+
+module Vagrant
+  class Action
+    module VM
+      class ForwardPorts
+        include ForwardPortsHelpers
+
+        def initialize(app,env)
+          @app = app
+          @env = env
+
+          threshold_check unless ENV["USER"] == "root"
+          external_collision_check
+        end
+
+        #--------------------------------------------------------------
+        # Prepare Helpers - These functions are not involved in actually
+        # executing the action
+        #--------------------------------------------------------------
+
+        # 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|
+            raise Errors::ForwardPortBelowThreshold if options[:hostport] <= 1024
+          end
+        end
+
+        # 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
+
+        # 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
+
+          # 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
+
+          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
+          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]))
+        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)
+          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]
+            message_attributes = {
+              :name => name,
+              :guest_port => options[:guestport],
+              :host_port => options[:hostport],
+              :adapter => adapter + 1
+            }
+
+            # 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))
+            end
+          end
+        end
+
+        #--------------------------------------------------------------
+        # General Helpers
+        #--------------------------------------------------------------
+
+        # 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Vagrant
+  class Action
+    module VM
+      # Helper methods for forwarding ports. Requires that the environment
+      # is set to the `@env` instance variable.
+      module ForwardPortsHelpers
+        # Returns an array of used ports. This method is implemented
+        # differently depending on the VirtualBox version, but the
+        # behavior is the same.
+        #
+        # @return [Array<String>]
+        def used_ports
+          result = VirtualBox::VM.all.collect do |vm|
+            if vm.accessible? && vm.running? && vm.uuid != @env["vm"].uuid
+              vm.network_adapters.collect do |na|
+                na.nat_driver.forwarded_ports.collect do |fp|
+                  fp.hostport.to_i
+                end
+              end
+            end
+          end
+
+          result.flatten.uniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Vagrant
+  class Action
+    module VM
+      class Halt
+        def initialize(app, env, options=nil)
+          @app = app
+          env.merge!(options || {})
+        end
+
+        def call(env)
+          if env["vm"].created? && env["vm"].vm.running?
+            env["vm"].system.halt if !env["force"]
+
+            if env["vm"].vm.state(true) != :powered_off
+              env.ui.info I18n.t("vagrant.actions.vm.halt.force")
+              env["vm"].vm.stop
+            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
+  class Action
+    module VM
+      class HostName
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+
+          host_name = env["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)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Vagrant
+  class 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.env.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)
+          end
+
+          # Clear the line one last time since the progress meter doesn't disappear
+          # immediately.
+          env.ui.clear_line
+
+          # Flag as erroneous and return if import failed
+          raise Errors::VMImportFailure if !env["vm"].vm
+
+          # 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
+            env["actions"].run(:destroy)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Vagrant
+  class Action
+    module VM
+      class MatchMACAddress
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          raise Errors::VMBaseMacNotSpecified if !env.env.config.vm.base_mac
+
+          # Create the proc which we want to use to modify the virtual machine
+          proc = lambda do |vm|
+            env.ui.info I18n.t("vagrant.actions.vm.match_mac.matching")
+            vm.network_adapters.first.mac_address = env["config"].vm.base_mac
+          end
+
+          # Add the proc to the modification chain
+          env["vm.modify"].call(proc)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end