vagrantup 0.2.0 → 0.3.0

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

@@ -7,19 +7,9 @@ module Vagrant
             next if !vm.running? || vm.uuid == @runner.uuid
 
             vm.forwarded_ports.each do |fp|
-              Vagrant.config.vm.forwarded_ports.each do |name, options|
+              @runner.env.config.vm.forwarded_ports.each do |name, options|
                 if fp.hostport.to_s == options[:hostport].to_s
-                  raise ActionException.new(<<-msg)
-Vagrant cannot forward the specified ports on this VM, since they
-would collide with another VirtualBox virtual machine's forwarded
-ports! The "#{name}" forwarded port (#{fp.hostport}) is already in use on the host
-machine.
-
-To fix this, modify your current projects Vagrantfile to use another
-port. Example, where '1234' would be replaced by a unique host port:
-
-config.vm.forward_port("#{name}", #{options[:guestport]}, 1234)
-msg
+                  raise ActionException.new(:vm_port_collision, :name => name, :hostport => fp.hostport.to_s, :guestport => options[:guestport].to_s)
                 end
               end
             end
@@ -33,13 +23,13 @@ msg
 
         def clear
           logger.info "Deleting any previously set forwarded ports..."
-          @runner.vm.forwarded_ports.collect { |p| p.destroy(true) }
+          @runner.vm.forwarded_ports.collect { |p| p.destroy }
         end
 
         def forward_ports
           logger.info "Forwarding ports..."
 
-          Vagrant.config.vm.forwarded_ports.each do |name, options|
+          @runner.env.config.vm.forwarded_ports.each do |name, options|
             logger.info "Forwarding \"#{name}\": #{options[:guestport]} => #{options[:hostport]}"
             port = VirtualBox::ForwardedPort.new
             port.name = name
@@ -48,7 +38,7 @@ msg
             @runner.vm.forwarded_ports << port
           end
 
-          @runner.vm.save(true)
+          @runner.vm.save
         end
       end
     end

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

@@ -3,10 +3,12 @@ module Vagrant
     module VM
       class Halt < Base
         def execute!
-          raise ActionException.new("VM is not running! Nothing to shut down!") unless @runner.vm.running?
+          raise ActionException.new(:vm_not_running) unless @runner.vm.running?
 
-          logger.info "Forcing shutdown of VM..."
-          @runner.vm.stop(true)
+          @runner.invoke_around_callback(:halt) do
+            logger.info "Forcing shutdown of VM..."
+            @runner.vm.stop
+          end
         end
       end
     end

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

@@ -2,13 +2,20 @@ module Vagrant
   module Actions
     module VM
       class Import < Base
+        include Util::ProgressMeter
+
         def execute!
           @runner.invoke_around_callback(:import) do
             Busy.busy do
-              logger.info "Importing base VM (#{Vagrant::Env.box.ovf_file})..."
+              logger.info "Importing base VM (#{@runner.env.box.ovf_file})..."
               # Use the first argument passed to the action
-              @runner.vm = VirtualBox::VM.import(Vagrant::Env.box.ovf_file)
-              raise ActionException.new("The VM import failed! Try running `VBoxManage import` on the box file manually for more verbose error output.") unless @runner.vm
+              @runner.vm = VirtualBox::VM.import(@runner.env.box.ovf_file) do |progress|
+                update_progress(progress, 100, false)
+              end
+
+              complete_progress
+
+              raise ActionException.new(:virtualbox_import_failure) unless @runner.vm
             end
           end
         end

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

@@ -4,9 +4,7 @@ module Vagrant
       class MoveHardDrive < Base
         def execute!
           unless @runner.powered_off?
-            error_and_exit(<<-error)
-The virtual machine must be powered off to move its disk.
-error
+            error_and_exit(:vm_power_off_to_move_hd)
             return
           end
 

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

@@ -16,12 +16,12 @@ module Vagrant
         def prepare
           # Verify the existance of all the additional files, if any
           @include_files.each do |file|
-            raise ActionException.new("#{file} does not exist") unless File.exists?(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("Package must be used in conjunction with export.") unless @export_action
+          raise ActionException.new(:packaged_requires_export) unless @export_action
         end
 
         def execute!
@@ -29,28 +29,51 @@ module Vagrant
         end
 
         def tar_path
-          File.join(FileUtils.pwd, "#{out_path}#{Vagrant.config.package.extension}")
+          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} ..."
+          logger.info "Packaging VM into #{tar_path}..."
           File.open(tar_path, File::CREAT | File::WRONLY, 0644) do |tar|
             Archive::Tar::Minitar::Output.open(tar) do |output|
               begin
                 current_dir = FileUtils.pwd
 
-                include_files.each do |f|
-                  logger.info "Packaging additional file: #{f}"
-                  Archive::Tar::Minitar.pack_file(f, output)
-                end
+                copy_include_files
+                create_vagrantfile
 
                 FileUtils.cd(temp_path)
-
-                Dir.glob(File.join(".", "*")).each do |entry|
+                Dir.glob(File.join(".", "**", "*")).each do |entry|
                   Archive::Tar::Minitar.pack_file(entry, output)
                 end
               ensure

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

@@ -19,8 +19,8 @@ module Vagrant
           end
 
           if provisioner.is_a?(Class)
-            @provisioner = provisioner.new
-            raise ActionException.new("Provisioners must be an instance of Vagrant::Provisioners::Base") unless @provisioner.is_a?(Provisioners::Base)
+            @provisioner = provisioner.new(@runner.env)
+            raise ActionException.new(:provisioner_invalid_class) unless @provisioner.is_a?(Provisioners::Base)
           elsif provisioner.is_a?(Symbol)
             # We have a few hard coded provisioners for built-ins
             mapping = {
@@ -29,8 +29,8 @@ module Vagrant
             }
 
             provisioner_klass = mapping[provisioner]
-            raise ActionException.new("Unknown provisioner type: #{provisioner}") if provisioner_klass.nil?
-            @provisioner = provisioner_klass.new
+            raise ActionException.new(:provisioner_unknown_type, :provisioner => provisioner.to_s) if provisioner_klass.nil?
+            @provisioner = provisioner_klass.new(@runner.env)
           end
 
           logger.info "Provisioning enabled with #{@provisioner.class}"

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

@@ -5,7 +5,7 @@ module Vagrant
         def prepare
           steps = [Customize, ForwardPorts, SharedFolders, Boot]
           steps.unshift(Halt) if @runner.vm.running?
-          steps << Provision if !Vagrant.config.vm.provisioner.nil?
+          steps << Provision if !@runner.env.config.vm.provisioner.nil?
 
           steps.each do |action_klass|
             @runner.add_action(action_klass)

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

@@ -4,7 +4,7 @@ module Vagrant
       class Resume < Base
         def execute!
           if !@runner.vm.saved?
-            raise ActionException.new("The vagrant virtual environment you are trying to resume is not in a suspended state.")
+            raise ActionException.new(:vm_not_suspended)
           end
 
           logger.info "Resuming suspended VM..."

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

@@ -3,7 +3,7 @@ module Vagrant
     module VM
       class SharedFolders < Base
         def shared_folders
-          Vagrant.config.vm.shared_folders.inject([]) do |acc, data|
+          @runner.env.config.vm.shared_folders.inject([]) do |acc, data|
             name, value = data
             acc << [name, File.expand_path(value[:hostpath]), value[:guestpath]]
           end
@@ -17,7 +17,7 @@ module Vagrant
         def after_boot
           logger.info "Mounting shared folders..."
 
-          Vagrant::SSH.execute do |ssh|
+          @runner.env.ssh.execute do |ssh|
             shared_folders.each do |name, hostpath, guestpath|
               logger.info "-- #{name}: #{guestpath}"
               ssh.exec!("sudo mkdir -p #{guestpath}")
@@ -43,11 +43,11 @@ module Vagrant
           shared_folders.each do |name, hostpath, guestpath|
             folder = VirtualBox::SharedFolder.new
             folder.name = name
-            folder.hostpath = hostpath
+            folder.host_path = hostpath
             @runner.vm.shared_folders << folder
           end
 
-          @runner.vm.save(true)
+          @runner.vm.save
         end
 
         def mount_folder(ssh, name, guestpath, sleeptime=5)
@@ -57,8 +57,8 @@ module Vagrant
 
           # Determine the permission string to attach to the mount command
           perms = []
-          perms << "uid=#{Vagrant.config.vm.shared_folder_uid}"
-          perms << "gid=#{Vagrant.config.vm.shared_folder_gid}"
+          perms << "uid=#{@runner.env.config.vm.shared_folder_uid}"
+          perms << "gid=#{@runner.env.config.vm.shared_folder_gid}"
           perms = " -o #{perms.join(",")}" if !perms.empty?
 
           attempts = 0
@@ -71,7 +71,7 @@ module Vagrant
             break unless result
 
             attempts += 1
-            raise ActionException.new("Failed to mount shared folders. vboxsf was not available.") if attempts >= 10
+            raise ActionException.new(:vm_mount_fail) if attempts >= 10
             sleep sleeptime
           end
         end

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

@@ -5,9 +5,10 @@ module Vagrant
         def prepare
           # Start is a "meta-action" so it really just queues up a bunch
           # of other actions in its place:
-          steps = [ForwardPorts, SharedFolders, Boot]
+          steps = [Boot]
+          steps.unshift([Customize, ForwardPorts, SharedFolders]) unless @runner.vm.saved?
 
-          steps.each do |action_klass|
+          steps.flatten.each do |action_klass|
             @runner.add_action(action_klass)
           end
         end

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

@@ -4,11 +4,11 @@ module Vagrant
       class Suspend < Base
         def execute!
           if !@runner.vm.running?
-            raise ActionException.new("The vagrant virtual environment you are trying to suspend must be running to be suspended.")
+            raise ActionException.new(:vm_not_running_for_suspend)
           end
 
           logger.info "Saving VM state and suspending execution..."
-          @runner.vm.save_state(true)
+          @runner.vm.save_state
         end
       end
     end

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

@@ -4,25 +4,15 @@ module Vagrant
       class Up < Base
         def prepare
           # If the dotfile is not a file, raise error
-          if File.exist?(Env.dotfile_path) && !File.file?(Env.dotfile_path)
-            raise ActionException.new(<<-msg)
-The dotfile which Vagrant uses to store the UUID of the project's
-virtual machine already exists and is not a file! The dotfile is
-currently configured to be `#{Env.dotfile_path}`
-
-To change this value, please see `config.vagrant.dotfile_name`
-
-This often exists if you're trying to create a Vagrant virtual
-environment from your home directory. To resolve this, you can either
-modify the configuration a bit, or simply use a different directory.
-msg
+          if File.exist?(@runner.env.dotfile_path) && !File.file?(@runner.env.dotfile_path)
+            raise ActionException.new(:dotfile_error, :env => @runner.env)
           end
 
           # Up is a "meta-action" so it really just queues up a bunch
           # of other actions in its place:
           steps = [Import, Customize, ForwardPorts, SharedFolders, Boot]
-          steps << Provision if !Vagrant.config.vm.provisioner.nil?
-          steps.insert(0, MoveHardDrive) if Vagrant.config.vm.hd_location
+          steps << Provision if !@runner.env.config.vm.provisioner.nil?
+          steps.insert(0, MoveHardDrive) if @runner.env.config.vm.hd_location
 
           steps.each do |action_klass|
             @runner.add_action(action_klass)
@@ -36,13 +26,13 @@ msg
 
         def persist
           logger.info "Persisting the VM UUID (#{@runner.uuid})..."
-          Env.persist_vm(@runner)
+          @runner.env.persist_vm
         end
 
         def setup_mac_address
           logger.info "Matching MAC addresses..."
-          @runner.vm.nics.first.macaddress = Vagrant.config[:vm][:base_mac]
-          @runner.vm.save(true)
+          @runner.vm.network_adapters.first.mac_address = @runner.env.config.vm.base_mac
+          @runner.vm.save
         end
       end
     end

data/lib/vagrant/active_list.rb

@@ -6,61 +6,68 @@ module Vagrant
 
     @@list = nil
 
-    class <<self
-      # Parses and returns the list of UUIDs from the active VM
-      # JSON file. This will cache the result, which can be reloaded
-      # by setting the `reload` parameter to true.
-      #
-      # @return [Array<String>]
-      def list(reload = false)
-        return @@list unless @@list.nil? || reload
+    # The environment this active list belongs to
+    attr_accessor :env
 
-        @@list ||= []
-        return @@list unless File.file?(path)
-        File.open(path, "r") do |f|
-          @@list = JSON.parse(f.read)
-        end
+    # Creates the instance of the ActiveList, with the given environment
+    # if specified
+    def initialize(env=nil)
+      @env = env
+    end
 
-        @@list
-      end
+    # Parses and returns the list of UUIDs from the active VM
+    # JSON file. This will cache the result, which can be reloaded
+    # by setting the `reload` parameter to true.
+    #
+    # @return [Array<String>]
+    def list(reload=false)
+      return @list unless @list.nil? || reload
 
-      # Returns an array of {Vagrant::VM} objects which are currently
-      # active.
-      def vms
-        list.collect { |uuid| Vagrant::VM.find(uuid) }.compact
+      @list ||= []
+      return @list unless File.file?(path)
+      File.open(path, "r") do |f|
+        @list = JSON.parse(f.read)
       end
 
-      # Returns an array of UUIDs filtered so each is verified to exist.
-      def filtered_list
-        vms.collect { |vm| vm.uuid }
-      end
+      @list
+    end
 
-      # Adds a virtual environment to the list of active virtual machines
-      def add(vm)
-        list << vm.uuid
-        list.uniq!
-        save
-      end
+    # Returns an array of {Vagrant::VM} objects which are currently
+    # active.
+    def vms
+      list.collect { |uuid| Vagrant::VM.find(uuid) }.compact
+    end
 
-      # Remove a virtual environment from the list of active virtual machines
-      def remove(vm)
-        vm = vm.uuid if vm.is_a?(Vagrant::VM)
-        list.delete(vm)
-        save
-      end
+    # Returns an array of UUIDs filtered so each is verified to exist.
+    def filtered_list
+      vms.collect { |vm| vm.uuid }
+    end
 
-      # Persists the list down to the JSON file.
-      def save
-        File.open(path, "w+") do |f|
-          f.write(filtered_list.to_json)
-        end
-      end
+    # Adds a virtual environment to the list of active virtual machines
+    def add(vm)
+      list << vm.uuid
+      list.uniq!
+      save
+    end
 
-      # Returns the path to the JSON file which holds the UUIDs of the
-      # active virtual machines managed by Vagrant.
-      def path
-        File.join(Env.home_path, FILENAME)
+    # Remove a virtual environment from the list of active virtual machines
+    def remove(vm)
+      vm = vm.uuid if vm.is_a?(Vagrant::VM)
+      list.delete(vm)
+      save
+    end
+
+    # Persists the list down to the JSON file.
+    def save
+      File.open(path, "w+") do |f|
+        f.write(filtered_list.to_json)
       end
     end
+
+    # Returns the path to the JSON file which holds the UUIDs of the
+    # active virtual machines managed by Vagrant.
+    def path
+      File.join(env.home_path, FILENAME)
+    end
   end
 end