vagrantup 0.3.4 → 0.4.0

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

@@ -6,10 +6,18 @@ module Vagrant
           raise ActionException.new(:vm_not_running) unless @runner.vm.running?
 
           @runner.invoke_around_callback(:halt) do
-            logger.info "Forcing shutdown of VM..."
-            @runner.vm.stop
+            @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

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

@@ -2,18 +2,16 @@ 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 (#{@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|
-                update_progress(progress.percent, 100, false)
+                logger.report_progress(progress.percent, 100, false)
               end
 
-              complete_progress
+              logger.clear_progress
 
               raise ActionException.new(:virtualbox_import_failure) unless @runner.vm
             end

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

@@ -26,7 +26,7 @@ module Vagrant
 
         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, Vagrant.config.vm.disk_image_format, true)
+          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
@@ -43,7 +43,7 @@ module Vagrant
 
         # Returns the path to the new location for the hard drive
         def new_image_path
-          File.join(Vagrant.config.vm.hd_location, hard_drive.image.filename)
+          File.join(@runner.env.config.vm.hd_location, hard_drive.image.filename)
         end
       end
     end

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

@@ -0,0 +1,120 @@
+module Vagrant
+  module Actions
+    module VM
+      class Network < Base
+        def before_destroy
+          # 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 = runner.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
+              logger.info "Destroying unused network interface..."
+              interface.destroy
+            end
+          end
+        end
+
+        def before_boot
+          assign_network if enable_network?
+        end
+
+        def after_boot
+          if enable_network?
+            logger.info "Enabling host only network..."
+
+            runner.system.prepare_host_only_network
+
+            runner.env.config.vm.network_options.compact.each do |network_options|
+              runner.system.enable_host_only_network(network_options)
+            end
+          end
+        end
+
+        def enable_network?
+          !runner.env.config.vm.network_options.compact.empty?
+        end
+
+        # Enables and assigns the host only network to the proper
+        # adapter on the VM, and saves the adapter.
+        def assign_network
+          logger.info "Preparing host only network..."
+
+          runner.env.config.vm.network_options.compact.each do |network_options|
+            adapter = runner.vm.network_adapters[network_options[:adapter]]
+            adapter.enabled = true
+            adapter.attachment_type = :host_only
+            adapter.host_interface = network_name(network_options)
+            adapter.save
+          end
+        end
+
+        # Returns the name of the proper host only network, or creates
+        # it if it does not exist. Vagrant determines if the host only
+        # network exists by comparing the netmask and the IP.
+        def network_name(net_options)
+          # First try to find a matching network
+          interfaces = VirtualBox::Global.global.host.network_interfaces
+          interfaces.each do |ni|
+            if net_options[:name]
+              return ni.name if net_options[:name] == ni.name
+            else
+              return ni.name if matching_network?(ni, net_options)
+            end
+          end
+
+          raise ActionException.new(:network_not_found, :name => net_options[:name]) if net_options[:name]
+
+          # One doesn't exist, create it.
+          logger.info "Creating new host only network for environment..."
+
+          ni = interfaces.create
+          ni.enable_static(network_ip(net_options[:ip], net_options[:netmask]),
+                           net_options[:netmask])
+          ni.name
+        end
+
+        # Tests if a network matches the given options by applying the
+        # netmask to the IP of the network and also to the IP of the
+        # virtual machine and see if they match.
+        def matching_network?(interface, net_options)
+          interface.network_mask == net_options[:netmask] &&
+            apply_netmask(interface.ip_address, interface.network_mask) ==
+            apply_netmask(net_options[:ip], net_options[:netmask])
+        end
+
+        # Applies a netmask to an IP and returns the corresponding
+        # parts.
+        def apply_netmask(ip, netmask)
+          ip = split_ip(ip)
+          netmask = split_ip(netmask)
+
+          ip.map do |part|
+            part & netmask.shift
+          end
+        end
+
+        # Splits an IP and converts each portion into an int.
+        def split_ip(ip)
+          ip.split(".").map do |i|
+            i.to_i
+          end
+        end
+
+        # Returns a "network IP" which is a "good choice" for the IP
+        # for the actual network based on the netmask.
+        def network_ip(ip, netmask)
+          parts = apply_netmask(ip, netmask)
+          parts[3] += 1;
+          parts.join(".")
+        end
+      end
+    end
+  end
+end

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

@@ -2,20 +2,16 @@ module Vagrant
   module Actions
     module VM
       class Package < Base
-        attr_accessor :out_path
-        attr_accessor :include_files
         attr_reader :export_action
 
-        def initialize(vm, out_path = nil, include_files = nil, *args)
+        def initialize(*args)
           super
-          @out_path = out_path || "package"
-          @include_files = include_files || []
           @temp_path = nil
         end
 
         def prepare
           # Verify the existance of all the additional files, if any
-          @include_files.each do |file|
+          include_files.each do |file|
             raise ActionException.new(:package_include_file_doesnt_exist, :filename => file) unless File.exists?(file)
           end
 
@@ -28,6 +24,14 @@ module Vagrant
           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
@@ -64,7 +68,7 @@ module Vagrant
 
         def compress
           logger.info "Packaging VM into #{tar_path}..."
-          File.open(tar_path, File::CREAT | File::WRONLY, 0644) do |tar|
+          File.open(tar_path, Platform.tar_file_options) do |tar|
             Archive::Tar::Minitar::Output.open(tar) do |output|
               begin
                 current_dir = FileUtils.pwd

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

@@ -11,7 +11,7 @@ module Vagrant
         end
 
         def prepare
-          provisioner = Vagrant.config.vm.provisioner
+          provisioner = @runner.env.config.vm.provisioner
 
           if provisioner.nil?
             logger.info("Provisioning not enabled, ignoring this step")
@@ -19,7 +19,7 @@ module Vagrant
           end
 
           if provisioner.is_a?(Class)
-            @provisioner = provisioner.new(@runner.env)
+            @provisioner = provisioner.new(@runner)
             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
@@ -30,7 +30,7 @@ module Vagrant
 
             provisioner_klass = mapping[provisioner]
             raise ActionException.new(:provisioner_unknown_type, :provisioner => provisioner.to_s) if provisioner_klass.nil?
-            @provisioner = provisioner_klass.new(@runner.env)
+            @provisioner = provisioner_klass.new(@runner)
           end
 
           logger.info "Provisioning enabled with #{@provisioner.class}"

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

@@ -3,7 +3,7 @@ module Vagrant
     module VM
       class Reload < Base
         def prepare
-          steps = [Customize, ForwardPorts, SharedFolders, Boot]
+          steps = [Customize, ForwardPorts, SharedFolders, Network, Boot]
           steps.unshift(Halt) if @runner.vm.running?
           steps << Provision if !@runner.env.config.vm.provisioner.nil?
 
@@ -11,14 +11,7 @@ module Vagrant
             @runner.add_action(action_klass)
           end
         end
-
-        def after_halt
-          # This sleep is here to allow the VM to clean itself up. There appears
-          # nothing [obvious] in the VirtualBox API to automate this. For now, this
-          # is an interim solution.
-          sleep 1
-        end
       end
     end
   end
-end
+end

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

@@ -5,7 +5,7 @@ module Vagrant
         def shared_folders
           @runner.env.config.vm.shared_folders.inject([]) do |acc, data|
             name, value = data
-            acc << [name, File.expand_path(value[:hostpath]), value[:guestpath]]
+            acc << [name, File.expand_path(value[:hostpath], @runner.env.root_path), value[:guestpath], value[:syncpath]].compact
           end
         end
 
@@ -17,24 +17,30 @@ module Vagrant
         def after_boot
           logger.info "Mounting shared folders..."
 
-          @runner.env.ssh.execute do |ssh|
-            shared_folders.each do |name, hostpath, guestpath|
-              logger.info "-- #{name}: #{guestpath}"
-              ssh.exec!("sudo mkdir -p #{guestpath}")
-              mount_folder(ssh, name, guestpath)
-              ssh.exec!("sudo chown #{Vagrant.config.ssh.username} #{guestpath}")
+          @runner.ssh.execute do |ssh|
+            @runner.system.prepare_sync(ssh) if @runner.env.config.vm.sync_required
+
+            shared_folders.each do |name, hostpath, guestpath, syncpath|
+              logger.info "-- #{name}: #{syncpath ? guestpath + " -sync-> " + syncpath : guestpath}"
+              @runner.system.mount_shared_folder(ssh, name, guestpath)
+              if syncpath
+                @runner.system.create_sync(ssh, :syncpath => syncpath, :guestpath => guestpath)
+              end
             end
           end
         end
 
         def clear_shared_folders
-          logger.info "Clearing previously set shared folders..."
+          if runner.vm.shared_folders.length > 0
+            logger.info "Clearing previously set shared folders..."
 
-          @runner.vm.shared_folders.each do |shared_folder|
-            shared_folder.destroy
-          end
+            folders = @runner.vm.shared_folders.dup
+            folders.each do |shared_folder|
+              shared_folder.destroy
+            end
 
-          @runner.reload!
+            @runner.reload!
+          end
         end
 
         def create_metadata
@@ -49,33 +55,7 @@ module Vagrant
 
           @runner.vm.save
         end
-
-        def mount_folder(ssh, name, guestpath, sleeptime=5)
-          # Note: This method seems pretty OS-specific and could also use
-          # some configuration options. For now its duct tape and "works"
-          # but should be looked at in the future.
-
-          # Determine the permission string to attach to the mount command
-          perms = []
-          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
-          while true
-            result = ssh.exec!("sudo mount -t vboxsf#{perms} #{name} #{guestpath}") do |ch, type, data|
-              # net/ssh returns the value in ch[:result] (based on looking at source)
-              ch[:result] = !!(type == :stderr && data =~ /No such device/i)
-            end
-
-            break unless result
-
-            attempts += 1
-            raise ActionException.new(:vm_mount_fail) if attempts >= 10
-            sleep sleeptime
-          end
-        end
       end
     end
   end
-end
+end

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

@@ -6,12 +6,20 @@ module Vagrant
           # Start is a "meta-action" so it really just queues up a bunch
           # of other actions in its place:
           steps = [Boot]
-          steps.unshift([Customize, ForwardPorts, SharedFolders]) unless @runner.vm.saved?
+          if !@runner.vm || !@runner.vm.saved?
+            steps.unshift([Customize, ForwardPorts, SharedFolders, Network])
+            steps << Provision if provision?
+          end
 
           steps.flatten.each do |action_klass|
-            @runner.add_action(action_klass)
+            @runner.add_action(action_klass, options)
           end
         end
+
+        def provision?
+          enabled = options[:provision].nil? ? true : options[:provision]
+          !@runner.env.config.vm.provisioner.nil? && enabled
+        end
       end
     end
   end

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

@@ -10,23 +10,22 @@ module Vagrant
 
           # 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 !@runner.env.config.vm.provisioner.nil?
+          steps = [Import, Start]
           steps.insert(0, MoveHardDrive) if @runner.env.config.vm.hd_location
 
           steps.each do |action_klass|
-            @runner.add_action(action_klass)
+            @runner.add_action(action_klass, options)
           end
         end
 
         def after_import
-          persist
+          update_dotfile
           setup_mac_address
         end
 
-        def persist
+        def update_dotfile
           logger.info "Persisting the VM UUID (#{@runner.uuid})..."
-          @runner.env.persist_vm
+          @runner.env.update_dotfile
         end
 
         def setup_mac_address

data/lib/vagrant/active_list.rb

@@ -23,30 +23,40 @@ module Vagrant
     def list(reload=false)
       return @list unless @list.nil? || reload
 
-      @list ||= []
+      @list ||= {}
       return @list unless File.file?(path)
       File.open(path, "r") do |f|
-        @list = JSON.parse(f.read)
+        begin
+          @list = JSON.parse(f.read)
+        rescue Exception
+          @list = {}
+        end
+
+        # This forces earlier versions of Vagrant to use the new hash
+        # format. Clearing out the old data isn't a big deal since it
+        # was never used.
+        @list = {} unless @list.is_a?(Hash)
       end
 
       @list
     end
 
-    # Returns an array of {Vagrant::VM} objects which are currently
-    # active.
-    def vms
-      list.collect { |uuid| Vagrant::VM.find(uuid) }.compact
-    end
-
     # Returns an array of UUIDs filtered so each is verified to exist.
-    def filtered_list
-      vms.collect { |vm| vm.uuid }
+    def filter_list
+      list.each do |uuid, data|
+        list.delete(uuid) unless Vagrant::VM.find(uuid, env)
+      end
+
+      list
     end
 
     # Adds a virtual environment to the list of active virtual machines
     def add(vm)
-      list << vm.uuid
-      list.uniq!
+      list[vm.uuid] = {
+        :path => env.root_path,
+        :created_at => Time.now.to_i
+      }
+
       save
     end
 
@@ -60,7 +70,7 @@ module Vagrant
     # Persists the list down to the JSON file.
     def save
       File.open(path, "w+") do |f|
-        f.write(filtered_list.to_json)
+        f.write(filter_list.to_json)
       end
     end