vagrant 0.4.2 → 0.5.0

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

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), 'nfs_helpers')
+
+module Vagrant
+  class Action
+    module VM
+      class ClearNFSExports
+        include NFSHelpers
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          clear_nfs_exports(env)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Vagrant
+  class Action
+    module VM
+      class ClearSharedFolders
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env = env
+
+          clear_shared_folders
+          @app.call(env)
+        end
+
+        def clear_shared_folders
+          if @env["vm"].vm.shared_folders.length > 0
+            @env.logger.info "Clearing previously set shared folders..."
+
+            folders = @env["vm"].vm.shared_folders.dup
+            folders.each do |shared_folder|
+              shared_folder.destroy
+            end
+
+            @env["vm"].reload!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Vagrant
+  class Action
+    module VM
+      class Customize
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if !env.env.config.vm.proc_stack.empty?
+            env.logger.info "Running any VM customizations..."
+            env.env.config.vm.run_procs!(env["vm"].vm)
+            env["vm"].vm.save
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Vagrant
+  class Action
+    module VM
+      class Destroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env.logger.info "Destroying VM and associated drives..."
+          env["vm"].vm.destroy(:destroy_medium => :delete)
+          env["vm"].vm = nil
+          env.env.update_dotfile
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+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)
+          # We need to check if the host only network specified by any
+          # of the adapters would not have any more clients if it was
+          # destroyed. And if so, then destroy the host only network
+          # itself.
+          interfaces = env["vm"].vm.network_adapters.collect do |adapter|
+            adapter.host_interface_object
+          end
+
+          interfaces.compact.uniq.each do |interface|
+            # Destroy the network interface if there is only one
+            # attached VM (which must be this VM)
+            if interface.attached_vms.length == 1
+              env.logger.info "Destroying unused network interface..."
+              interface.destroy
+            end
+          end
+
+          # Continue along
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Vagrant
+  class Action
+    module VM
+      # Middleware to disable all host only networks on the
+      # VM
+      class DisableNetworks
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          env.logger.info "Disabling host only networks..."
+
+          env["vm"].vm.network_adapters.each do |adapter|
+            next if adapter.attachment_type != :host_only
+            adapter.enabled = false
+            adapter.save
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+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
+
+          return env.error!(:vm_power_off_to_package) if !@env["vm"].vm.powered_off?
+          return if env.error?
+
+          setup_temp_dir
+          export
+
+          @app.call(env) if !env.error?
+
+          cleanup
+        end
+
+        def cleanup
+          if temp_dir && File.exist?(temp_dir)
+            FileUtils.rm_rf(temp_dir)
+          end
+        end
+
+        def setup_temp_dir
+          @env.logger.info "Creating temporary directory for export..."
+          @temp_dir = @env["export.temp_dir"] = File.join(@env.env.tmp_path, Time.now.to_i.to_s)
+          FileUtils.mkpath(@env["export.temp_dir"])
+        end
+
+        def export
+          @env.logger.info "Exporting VM to #{ovf_path}..."
+          @env["vm"].vm.export(ovf_path) do |progress|
+            @env.logger.report_progress(progress.percent, 100, false)
+          end
+        ensure
+          @env.logger.clear_progress
+        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,121 @@
+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
+          external_collision_check if !env.error?
+        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|
+            return @env.error!(:vm_port_below_threshold) 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_s)
+              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.
+            return @env.error!(:vm_port_collision, :name => name, :hostport => options[:hostport].to_s, :guestport => options[:guestport].to_s, :adapter => options[:adapter])
+          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?
+            return @env.error!(:vm_port_auto_empty, :vm_name => @env["vm"].name, :name => name, :options => 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.logger.info "Fixed port collision: #{name} now on port #{options[:hostport]}"
+        end
+
+        #--------------------------------------------------------------
+        # Execution
+        #--------------------------------------------------------------
+        def call(env)
+          @env = env
+
+          forward_ports
+
+          @app.call(env)
+        end
+
+        def forward_ports
+          @env.logger.info "Forwarding ports..."
+
+          @env.env.config.vm.forwarded_ports.each do |name, options|
+            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 @env["vm"].vm.network_adapters[adapter].attachment_type == :nat
+              @env.logger.info "Forwarding \"#{name}\": #{options[:guestport]} on adapter \##{adapter+1} => #{options[:hostport]}"
+              forward_port(name, options)
+            else
+              @env.logger.info "VirtualBox adapter \##{adapter+1} not configured as \"NAT\"."
+              @env.logger.info "Skipped port forwarding \"#{name}\": #{options[:guestport]} on adapter\##{adapter+1} => #{options[:hostport]}"
+            end
+          end
+
+          @env["vm"].vm.save
+          @env["vm"].reload!
+        end
+
+        #--------------------------------------------------------------
+        # General Helpers
+        #--------------------------------------------------------------
+
+        # Forwards a port.
+        def forward_port(name, options)
+          port = VirtualBox::NATForwardedPort.new
+          port.name = name
+          port.guestport = options[:guestport]
+          port.hostport = options[:hostport]
+          @env["vm"].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.running? && vm.uuid != @env["vm"].uuid
+              vm.network_adapters.collect do |na|
+                na.nat_driver.forwarded_ports.collect do |fp|
+                  fp.hostport.to_s
+                end
+              end
+            end
+          end
+
+          result.flatten.uniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Vagrant
+  class Action
+    module VM
+      class Halt
+        include ExceptionCatcher
+
+        def initialize(app, env, options=nil)
+          @app = app
+          env.merge!(options || {})
+        end
+
+        def call(env)
+          if env["vm"].vm.running?
+            if !env["force"]
+              catch_action_exception(env) { env["vm"].system.halt }
+              return if env.error?
+            end
+
+            if env["vm"].vm.state(true) != :powered_off
+              env.logger.info "Forcing shutdown of VM..."
+              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/import.rb

@@ -0,0 +1,33 @@
+module Vagrant
+  class Action
+    module VM
+      class Import
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env.logger.info "Importing base VM (#{env.env.box.ovf_file})"
+
+          begin
+            # Import the virtual machine
+            env.env.vm.vm = VirtualBox::VM.import(env.env.box.ovf_file) do |progress|
+              env.logger.report_progress(progress.percent, 100, false)
+            end
+
+            # Flag as erroneous and return if import failed
+            return env.error!(:virtualbox_import_failure) if !env['vm'].vm
+          ensure
+            env.logger.clear_progress
+          end
+
+          # Import completed successfully. Continue the chain
+          @app.call(env) if !env.error?
+
+          # Interrupted, destroy the VM
+          env["actions"].run(:destroy) if env.interrupted?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Vagrant
+  class Action
+    module VM
+      class MatchMACAddress
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env.logger.info "Matching MAC addresses..."
+          env["vm"].vm.network_adapters.first.mac_address = env.env.config.vm.base_mac
+          env["vm"].vm.save
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end