vagrant 0.3.4 → 0.4.0

data/Gemfile

@@ -1,4 +1,4 @@
-source :gemcutter
+source "http://rubygems.org"
 
 # Gems required for the lib to even run
 gem "virtualbox", :git => "git://github.com/mitchellh/virtualbox.git"
@@ -7,7 +7,6 @@ gem "net-scp", ">= 1.0.2"
 gem "json", ">= 1.2.4"
 gem "archive-tar-minitar", "= 0.5.2"
 gem "mario", "~> 0.0.6"
-gem "jeweler", "~> 1.4.0"
 
 # Gems required for testing only. To install run
 # gem bundle test
@@ -15,4 +14,5 @@ group :test do
   gem "contest", ">= 0.1.2"
   gem "mocha"
   gem "ruby-debug", ">= 0.10.3" if RUBY_VERSION < '1.9'
+  gem "jeweler", "~> 1.4.0"
 end

data/README.md

@@ -6,7 +6,7 @@
 
 Vagrant is a tool for building and distributing virtualized development environments.
 
-By providing automated creation and provisioning of virtual machines using [Sun’s VirtualBox](http://www.virtualbox.org),
+By providing automated creation and provisioning of virtual machines using [Oracle’s VirtualBox](http://www.virtualbox.org),
 Vagrant provides the tools to create and configure lightweight, reproducible, and portable
 virtual environments. For more information, see the part of the getting started guide
 on ”[Why Vagrant?](http://vagrantup.com/docs/getting-started/index.html)”
@@ -48,6 +48,6 @@ To hack on vagrant, you'll need [bundler](http://github.com/carlhuda/bundler) wh
 be installed with a simple `sudo gem install bundler`. Afterwords, do the following:
 
     bundle install
-    rake
+    bundle exec rake
 
 This will run the test suite, which should come back all green! Then you're good to go!

data/Rakefile

@@ -10,7 +10,7 @@ begin
     gemspec.homepage = "http://github.com/mitchellh/vagrant"
     gemspec.authors = ["Mitchell Hashimoto", "John Bender"]
 
-    gemspec.add_dependency('virtualbox', '~> 0.6.1')
+    gemspec.add_dependency('virtualbox', '~> 0.7.0')
     gemspec.add_dependency('net-ssh', '>= 2.0.19')
     gemspec.add_dependency('net-scp', '>= 1.0.2')
     gemspec.add_dependency('json', '>= 1.2.0')

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.4.0

data/config/default.rb

@@ -5,22 +5,32 @@ Vagrant::Config.run do |config|
   config.vagrant.home = "~/.vagrant"
 
   config.ssh.username = "vagrant"
-  config.ssh.password = "vagrant"
   config.ssh.host = "localhost"
+  config.ssh.port = 22
   config.ssh.forwarded_port_key = "ssh"
   config.ssh.max_tries = 10
   config.ssh.timeout = 30
   config.ssh.private_key_path = File.join(PROJECT_ROOT, 'keys', 'vagrant')
 
+  config.vm.auto_port_range = (2200..2250)
   config.vm.box_ovf = "box.ovf"
   config.vm.base_mac = "0800279C2E42"
-  config.vm.project_directory = "/vagrant"
-  config.vm.forward_port("ssh", 22, 2222)
+  config.vm.forward_port("ssh", 22, 2222, :auto => true)
   config.vm.disk_image_format = 'VMDK'
   config.vm.provisioner = nil
   config.vm.shared_folder_uid = nil
   config.vm.shared_folder_gid = nil
   config.vm.boot_mode = "vrdp"
+  config.vm.system = :linux
+
+  # Share the root folder. This can then be overridden by
+  # other Vagrantfiles, if they wish.
+  config.vm.share_folder("v-root", "/vagrant", ".")
+
+  # TODO new config class
+  config.vm.sync_opts = "-terse -group -owner -batch -silent"
+  config.vm.sync_script = "/tmp/sync"
+  config.vm.sync_crontab_entry_file = "/tmp/crontab-entry"
 
   config.package.name = 'vagrant'
   config.package.extension = '.box'

data/lib/vagrant.rb

@@ -1,19 +1,16 @@
-libdir = File.dirname(__FILE__)
-PROJECT_ROOT = File.join(libdir, '..') unless defined?(PROJECT_ROOT)
+libdir = File.join(File.dirname(__FILE__), "vagrant")
+PROJECT_ROOT = File.join(libdir, '..', "..") unless defined?(PROJECT_ROOT)
 
-# The libs which must be loaded prior to the rest
-%w{tempfile open-uri json pathname logger uri net/http virtualbox net/ssh archive/tar/minitar
+# First, load the various libs which Vagrant requires
+%w{tempfile json pathname logger virtualbox net/ssh archive/tar/minitar
   net/scp fileutils mario}.each do |lib|
   require lib
 end
 
-# The vagrant specific files which must be loaded prior to the rest
-%w{vagrant/util vagrant/util/stacked_proc_runner vagrant/util/progress_meter vagrant/actions/base vagrant/downloaders/base vagrant/actions/collection
-  vagrant/actions/runner vagrant/config vagrant/provisioners/base vagrant/provisioners/chef vagrant/commands/base vagrant/commands/box}.each do |f|
-  require File.expand_path(f, libdir)
-end
+# Then load the glob loader, which will handle loading everything else
+require File.expand_path("util/glob_loader", libdir)
 
-# Glob require the rest
-Dir[File.join(libdir, "vagrant", "**", "*.rb")].each do |f|
-  require File.expand_path(f)
-end
+# Load them up
+Vagrant::GlobLoader.glob_require(libdir, %w{util/stacked_proc_runner
+  actions/base downloaders/base actions/collection actions/runner config
+  provisioners/base provisioners/chef systems/base commands/base commands/box})

data/lib/vagrant/actions/base.rb

@@ -26,14 +26,26 @@ module Vagrant
       # The {Runner runner} which is executing the action
       attr_reader :runner
 
+      # Any options which are passed into the initializer as a hash.
+      attr_reader :options
+
       # Included so subclasses don't need to include it themselves.
       include Vagrant::Util
 
+      # A helper method for logging which simply gets the logger from
+      # the runner. Since actions tend to log quite a bit, this
+      # removes the need to prefix `logger` with `@runner` over and
+      # over.
+      def logger
+        runner.env.logger
+      end
+
       # Initialization of the action, passing any arguments which may have
       # been given to the {Runner runner}. This method can be used by subclasses
       # to save any of the configuration options which are passed in.
-      def initialize(runner, *args)
+      def initialize(runner, options=nil)
         @runner = runner
+        @options = options || {}
       end
 
       # This method is called once per action, allowing the action
@@ -110,7 +122,7 @@ module Vagrant
         @key = key
         @data = data
 
-        message = Vagrant::Util::Errors.error_string(key, data)
+        message = Vagrant::Util::Translator.t(key, data)
         super(message)
       end
     end

data/lib/vagrant/actions/box/download.rb

@@ -18,7 +18,7 @@ module Vagrant
           [Downloaders::HTTP, Downloaders::File].each do |dler|
             if dler.match?(@runner.uri)
               logger.info "Downloading via #{dler}..."
-              @downloader = dler.new 
+              @downloader = dler.new(@runner.env)
             end
           end
 
@@ -48,15 +48,10 @@ module Vagrant
 
         def with_tempfile
           logger.info "Creating tempfile for storing box file..."
-          File.open(box_temp_path, file_options) do |tempfile|
+          File.open(box_temp_path, Platform.tar_file_options) do |tempfile|
             yield tempfile
           end
         end
-        
-        def file_options
-          # create, write only, fail if the file exists, binary if windows
-          File::WRONLY|File::EXCL|File::CREAT|(Mario::Platform.windows? ? File::BINARY : 0)
-        end
 
         def box_temp_path
           File.join(@runner.env.tmp_path, BASENAME + Time.now.to_i.to_s)

data/lib/vagrant/actions/box/verify.rb

@@ -23,7 +23,7 @@ module Vagrant
         def verify_appliance
           # We now try to read the applince. If it succeeds, we return true.
           VirtualBox::Appliance.new(@runner.ovf_file)
-        rescue VirtualBox::Exceptions::FileErrorException
+        rescue Exception
           raise ActionException.new(:box_verification_failed)
         end
       end

data/lib/vagrant/actions/runner.rb

@@ -69,7 +69,6 @@ module Vagrant
       # to execute a single action on an instance. The syntax for executing a
       # single method on an instance is the same as the {execute!} class method.
       def execute!(single_action=nil, *args)
-
         if single_action
           actions.clear
           add_action(single_action, *args)

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

@@ -2,10 +2,6 @@ module Vagrant
   module Actions
     module VM
       class Boot < Base
-        def prepare
-          @runner.env.config.vm.share_folder("v-root", @runner.env.config.vm.project_directory, @runner.env.root_path)
-        end
-
         def execute!
           @runner.invoke_around_callback(:boot) do
             # Startup the VM
@@ -28,9 +24,9 @@ module Vagrant
           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 #{Vagrant.config[:ssh][:max_tries]})..."
+            logger.info "Trying to connect (attempt ##{i+1} of #{@runner.env.config[:ssh][:max_tries]})..."
 
-            if @runner.env.ssh.up?
+            if @runner.ssh.up?
               logger.info "VM booted and ready for use!"
               return true
             end

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

@@ -3,13 +3,15 @@ module Vagrant
     module VM
       class Customize < Base
         def execute!
-          logger.info "Running any VM customizations..."
+          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)
+            # Run the customization procs over the VM
+            runner.env.config.vm.run_procs!(@runner.vm)
 
-          # Save the vm
-          @runner.vm.save
+            # Save the vm
+            runner.vm.save
+          end
         end
       end
     end

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

@@ -5,17 +5,18 @@ module Vagrant
         def execute!
           @runner.invoke_around_callback(:destroy) do
             destroy_vm
-            depersist
+            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 depersist
-          @runner.env.depersist_vm
+        def update_dotfile
+          @runner.env.update_dotfile
         end
       end
     end

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

@@ -3,15 +3,18 @@ module Vagrant
     module VM
       class Down < Base
         def prepare
-          @runner.add_action(Halt) if @runner.vm.running?
+          # 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 GUI to clean itself up.
+          # 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) if @runner.env.config.vm.boot_mode == "gui"
+          Kernel.sleep(1)
         end
       end
     end

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

@@ -2,8 +2,6 @@ module Vagrant
   module Actions
     module VM
       class Export < Base
-        include Util::ProgressMeter
-
         attr_reader :temp_dir
 
         def execute!
@@ -36,10 +34,10 @@ module Vagrant
         def export
           logger.info "Exporting VM to #{ovf_path}..."
           @runner.vm.export(ovf_path) do |progress|
-            update_progress(progress.percent, 100, false)
+            logger.report_progress(progress.percent, 100, false)
           end
 
-          complete_progress
+          logger.clear_progress
         end
       end
     end

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

@@ -3,17 +3,62 @@ module Vagrant
     module VM
       class ForwardPorts < Base
         def prepare
-          VirtualBox::VM.all.each do |vm|
-            next if !vm.running? || vm.uuid == @runner.uuid
-
-            vm.forwarded_ports.each do |fp|
-              @runner.env.config.vm.forwarded_ports.each do |name, options|
-                if fp.hostport.to_s == options[:hostport].to_s
-                  raise ActionException.new(:vm_port_collision, :name => name, :hostport => fp.hostport.to_s, :guestport => options[:guestport].to_s)
-                end
+          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
+          # Flatten all the already-created forwarded ports into a
+          # flat list.
+          used_ports = VirtualBox::VM.all.collect do |vm|
+            if vm.running? && vm.uuid != runner.uuid
+              vm.forwarded_ports.collect do |fp|
+                fp.hostport.to_s
               end
             end
           end
+
+          used_ports.flatten!
+          used_ports.uniq!
+
+          runner.env.config.vm.forwarded_ports.each do |name, options|
+            if used_ports.include?(options[:hostport].to_s)
+              handle_collision(name, options, used_ports)
+            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, used_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 -= used_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
+          used_ports << options[:hostport]
+
+          # Notify the user
+          logger.info "Fixed port collision: #{name} now on port #{options[:hostport]}"
         end
 
         def execute!
@@ -22,23 +67,39 @@ module Vagrant
         end
 
         def clear
-          logger.info "Deleting any previously set forwarded ports..."
-          @runner.vm.forwarded_ports.collect { |p| p.destroy }
+          if runner.vm.forwarded_ports.length > 0
+            logger.info "Deleting any previously set forwarded ports..."
+            fp = runner.vm.forwarded_ports.dup
+            fp.collect { |p| p.destroy }
+            runner.reload!
+          end
         end
 
         def forward_ports
           logger.info "Forwarding ports..."
 
           @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
-            port.hostport = options[:hostport]
-            port.guestport = options[:guestport]
-            @runner.vm.forwarded_ports << port
+            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]}"
+               port = VirtualBox::ForwardedPort.new
+               port.name = name
+               port.hostport = options[:hostport]
+               port.guestport = options[:guestport]
+               port.instance = adapter
+               @runner.vm.forwarded_ports << port
+            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
       end
     end

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