vagrant 0.4.2 → 0.5.0

data/lib/vagrant/actions/vm/boot.rb

@@ -1,43 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Boot < Base
-        def execute!
-          @runner.invoke_around_callback(:boot) do
-            # Startup the VM
-            boot
-
-            # Wait for it to complete booting, or error if we could
-            # never detect it booted up successfully
-            if !wait_for_boot
-              error_and_exit(:vm_failed_to_boot)
-            end
-          end
-        end
-
-        def boot
-          logger.info "Booting VM..."
-          @runner.vm.start(@runner.env.config.vm.boot_mode)
-        end
-
-        def wait_for_boot(sleeptime=5)
-          logger.info "Waiting for VM to boot..."
-
-          @runner.env.config.ssh.max_tries.to_i.times do |i|
-            logger.info "Trying to connect (attempt ##{i+1} of #{@runner.env.config[:ssh][:max_tries]})..."
-
-            if @runner.ssh.up?
-              logger.info "VM booted and ready for use!"
-              return true
-            end
-
-            sleep sleeptime
-          end
-
-          logger.info "Failed to connect to VM! Failed to boot?"
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Customize < Base
-        def execute!
-          if !runner.env.config.vm.proc_stack.empty?
-            logger.info "Running any VM customizations..."
-
-            # Run the customization procs over the VM
-            runner.env.config.vm.run_procs!(@runner.vm)
-
-            # Save the vm
-            runner.vm.save
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Destroy < Base
-        def execute!
-          @runner.invoke_around_callback(:destroy) do
-            destroy_vm
-            update_dotfile
-          end
-        end
-
-        def destroy_vm
-          logger.info "Destroying VM and associated drives..."
-          @runner.vm.destroy(:destroy_medium => :delete)
-          @runner.vm = nil
-        end
-
-        def update_dotfile
-          @runner.env.update_dotfile
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/vm/down.rb

@@ -1,22 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Down < Base
-        def prepare
-          # The true as the 2nd parameter always forces the shutdown so its
-          # fast (since we're destroying anyways)
-          @runner.add_action(Halt, :force => true) if @runner.vm.running?
-          @runner.add_action(Network)
-          @runner.add_action(Destroy)
-        end
-
-        def after_halt
-          # This sleep is necessary to wait for the VM to clean itself up.
-          # There appears to be nothing in the API that does this "wait"
-          # for us.
-          Kernel.sleep(1)
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Export < Base
-        attr_reader :temp_dir
-
-        def execute!
-          setup_temp_dir
-          export
-        end
-
-        def cleanup
-          if temp_dir
-            logger.info "Removing temporary export directory..."
-            FileUtils.rm_r(temp_dir)
-          end
-        end
-
-        def rescue(exception)
-          cleanup
-        end
-
-        def setup_temp_dir
-          @temp_dir = File.join(@runner.env.tmp_path, Time.now.to_i.to_s)
-
-          logger.info "Creating temporary directory for export..."
-          FileUtils.mkpath(temp_dir)
-        end
-
-        def ovf_path
-          File.join(temp_dir, @runner.env.config.vm.box_ovf)
-        end
-
-        def export
-          logger.info "Exporting VM to #{ovf_path}..."
-          @runner.vm.export(ovf_path) do |progress|
-            logger.report_progress(progress.percent, 100, false)
-          end
-
-          logger.clear_progress
-        end
-      end
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class ForwardPorts < Base
-        def prepare
-          external_collision_check
-        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
-          runner.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.
-            raise ActionException.new(: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 = runner.env.config.vm.auto_port_range.to_a
-          range -= runner.env.config.vm.forwarded_ports.collect { |n, o| o[:hostport].to_i }
-          range -= existing_ports
-
-          if range.empty?
-            raise ActionException.new(:vm_port_auto_empty, :vm_name => @runner.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
-          logger.info "Fixed port collision: #{name} now on port #{options[:hostport]}"
-        end
-
-        def execute!
-          clear
-          forward_ports
-        end
-
-        def clear
-          if used_ports.length > 0
-            logger.info "Deleting any previously set forwarded ports..."
-            clear_ports
-            runner.reload!
-          end
-        end
-
-        def forward_ports
-          logger.info "Forwarding ports..."
-
-          runner.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 @runner.vm.network_adapters[adapter].attachment_type == :nat
-              logger.info "Forwarding \"#{name}\": #{options[:guestport]} on adapter \##{adapter+1} => #{options[:hostport]}"
-              forward_port(name, options)
-            else
-              logger.info "VirtualBox adapter \##{adapter+1} not configured as \"NAT\"."
-              logger.info "Skipped port forwarding \"#{name}\": #{options[:guestport]} on adapter\##{adapter+1} => #{options[:hostport]}"
-            end
-          end
-
-          runner.vm.save
-          runner.reload!
-        end
-
-        #------------------------------------------------------------
-        # VirtualBox version-specific helpers below. VirtualBox 3.2
-        # introduced a breaking change into the way that forwarded
-        # ports are handled. For backwards compatability with 3.1, we
-        # need this trickery.
-        #------------------------------------------------------------
-        # TODO In a future version, fix this.
-
-        # 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 != runner.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
-
-        # Deletes existing forwarded ports.
-        def clear_ports
-          runner.vm.network_adapters.each do |na|
-            na.nat_driver.forwarded_ports.dup.each do |fp|
-              fp.destroy
-            end
-          end
-        end
-
-        # Forwards a port.
-        def forward_port(name, options)
-          port = VirtualBox::NATForwardedPort.new
-          port.name = name
-          port.guestport = options[:guestport]
-          port.hostport = options[:hostport]
-          runner.vm.network_adapters[options[:adapter]].nat_driver.forwarded_ports << port
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Halt < Base
-        def execute!
-          raise ActionException.new(:vm_not_running) unless @runner.vm.running?
-
-          @runner.invoke_around_callback(:halt) do
-            @runner.system.halt if !options[:force]
-
-            if @runner.vm.state(true) != :powered_off
-              logger.info "Forcing shutdown of VM..."
-              @runner.vm.stop
-            end
-          end
-        end
-
-        def force?
-          !!options[:force]
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Import < Base
-        def execute!
-          @runner.invoke_around_callback(:import) do
-            Busy.busy do
-              logger.info "Importing base VM (#{@runner.env.box.ovf_file})..."
-              # Use the first argument passed to the action
-              @runner.vm = VirtualBox::VM.import(@runner.env.box.ovf_file) do |progress|
-                logger.report_progress(progress.percent, 100, false)
-              end
-
-              logger.clear_progress
-
-              raise ActionException.new(:virtualbox_import_failure) unless @runner.vm
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/vm/move_hard_drive.rb

@@ -1,51 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class MoveHardDrive < Base
-        def execute!
-          unless @runner.powered_off?
-            error_and_exit(:vm_power_off_to_move_hd)
-            return
-          end
-
-          destroy_drive_after { clone_and_attach }
-        end
-
-        def hard_drive
-          @hard_drive ||= find_hard_drive
-        end
-
-        # TODO won't work if the first disk is not the boot disk or even if there are multiple disks
-        def find_hard_drive
-          @runner.vm.storage_controllers.each do |sc|
-            sc.devices.each do |d|
-              return d if d.image.is_a?(VirtualBox::HardDrive)
-            end
-          end
-        end
-
-        def clone_and_attach
-          logger.info "Cloning current VM Disk to new location (#{new_image_path})..."
-          hard_drive.image = hard_drive.image.clone(new_image_path, @runner.env.config.vm.disk_image_format, true)
-
-          logger.info "Attaching new disk to VM ..."
-          @runner.vm.save
-        end
-
-        def destroy_drive_after
-          old_image = hard_drive.image
-
-          yield
-
-          logger.info "Destroying old VM Disk (#{old_image.filename})..."
-          old_image.destroy(true)
-        end
-
-        # Returns the path to the new location for the hard drive
-        def new_image_path
-          File.join(@runner.env.config.vm.hd_location, hard_drive.image.filename)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/vm/package.rb

@@ -1,94 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Package < Base
-        attr_reader :export_action
-
-        def initialize(*args)
-          super
-          @temp_path = nil
-        end
-
-        def prepare
-          raise ActionException.new(:box_file_exists, :output_file => tar_path) if File.exist?(tar_path)
-
-          # Verify the existance of all the additional files, if any
-          include_files.each do |file|
-            raise ActionException.new(:package_include_file_doesnt_exist, :filename => file) unless File.exists?(file)
-          end
-
-          # Get the export action and store a reference to it
-          @export_action = @runner.find_action(Export)
-          raise ActionException.new(:packaged_requires_export) unless @export_action
-        end
-
-        def execute!
-          compress
-        end
-
-        def out_path
-          options[:output] || "package"
-        end
-
-        def include_files
-          options[:include] || []
-        end
-
-        def tar_path
-          File.join(FileUtils.pwd, "#{out_path}#{@runner.env.config.package.extension}")
-        end
-
-        def temp_path
-          export_action.temp_dir
-        end
-
-        # This method copies the include files (passed in via command line)
-        # to the temporary directory so they are included in a sub-folder within
-        # the actual box
-        def copy_include_files
-          if include_files.length > 0
-            include_dir = File.join(temp_path, "include")
-            FileUtils.mkdir_p(include_dir)
-
-            include_files.each do |f|
-              logger.info "Packaging additional file: #{f}"
-              FileUtils.cp(f, include_dir)
-            end
-          end
-        end
-
-        # This method creates the auto-generated Vagrantfile at the root of the
-        # box. This Vagrantfile contains the MAC address so that the user doesn't
-        # have to worry about it.
-        def create_vagrantfile
-          File.open(File.join(temp_path, "Vagrantfile"), "w") do |f|
-            f.write(TemplateRenderer.render("package_Vagrantfile", {
-              :base_mac => @runner.vm.network_adapters.first.mac_address
-            }))
-          end
-        end
-
-        def compress
-          logger.info "Packaging VM into #{tar_path}..."
-          File.open(tar_path, Platform.tar_file_options) do |tar|
-            Archive::Tar::Minitar::Output.open(tar) do |output|
-              begin
-                current_dir = FileUtils.pwd
-
-                copy_include_files
-                create_vagrantfile
-
-                FileUtils.cd(temp_path)
-                Dir.glob(File.join(".", "**", "*")).each do |entry|
-                  Archive::Tar::Minitar.pack_file(entry, output)
-                end
-              ensure
-                FileUtils.cd(current_dir)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end