vagrant 0.4.1 → 0.4.2

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.7.0')
+    gemspec.add_dependency('virtualbox', '~> 0.7.3')
     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.4.1
+0.4.2

data/config/default.rb

@@ -27,10 +27,16 @@ Vagrant::Config.run do |config|
   # 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.unison.folder_suffix = ".sync"
+  config.unison.script = "/tmp/vagrant-unison"
+  config.unison.options = "-terse -owner -group -batch"
+  config.unison.crontab_entry_file = "/tmp/vagrant-unison-crontab"
+  config.unison.log_file = "/tmp/v-unison-log-%s"
+
+  # TODO fix these
+  # 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/actions/vm/forward_ports.rb

@@ -100,18 +100,10 @@ module Vagrant
         def used_ports
           result = VirtualBox::VM.all.collect do |vm|
             if vm.running? && vm.uuid != runner.uuid
-              if VirtualBox.version =~ /^3\.1\./
-                # VirtualBox 3.1.x uses forwarded ports via extra-data
-                vm.forwarded_ports.collect do |fp|
+              vm.network_adapters.collect do |na|
+                na.nat_driver.forwarded_ports.collect do |fp|
                   fp.hostport.to_s
                 end
-              else
-                # VirtualBox 3.2.x uses forwarded ports via NAT engines
-                vm.network_adapters.collect do |na|
-                  na.nat_driver.forwarded_ports.collect do |fp|
-                    fp.hostport.to_s
-                  end
-                end
               end
             end
           end
@@ -121,34 +113,20 @@ module Vagrant
 
         # Deletes existing forwarded ports.
         def clear_ports
-          if VirtualBox.version =~ /^3\.1\./
-            fp = runner.vm.forwarded_ports.dup
-            fp.each { |p| p.destroy }
-          else
-            runner.vm.network_adapters.each do |na|
-              na.nat_driver.forwarded_ports.dup.each do |fp|
-                fp.destroy
-              end
+          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)
-          if VirtualBox.version =~ /^3\.1\./
-            port = VirtualBox::ForwardedPort.new
-            port.name = name
-            port.hostport = options[:hostport]
-            port.guestport = options[:guestport]
-            port.instance = options[:adapter]
-            runner.vm.forwarded_ports << port
-          else
-            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
+          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

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

@@ -2,6 +2,13 @@ module Vagrant
   module Actions
     module VM
       class Network < Base
+        def prepare
+          # Verify that the given network options are valid
+          runner.env.config.vm.network_options.compact.each do |network_options|
+            verify_no_bridge_collision(network_options)
+          end
+        end
+
         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
@@ -55,6 +62,24 @@ module Vagrant
           end
         end
 
+        # Verifies that there is no collision with a bridged network interface
+        # for the given network options.
+        def verify_no_bridge_collision(net_options)
+          # First try to find a matching network
+          interfaces = VirtualBox::Global.global.host.network_interfaces
+          interfaces.each do |ni|
+            next if ni.interface_type == :host_only
+
+            result = if net_options[:name]
+              true if net_options[:name] == ni.name
+            else
+              true if matching_network?(ni, net_options)
+            end
+
+            raise ActionException.new(:network_collides) if result
+          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.
@@ -62,6 +87,10 @@ module Vagrant
           # First try to find a matching network
           interfaces = VirtualBox::Global.global.host.network_interfaces
           interfaces.each do |ni|
+            # Ignore non-host only interfaces which may also match,
+            # since they're not valid options.
+            next if ni.interface_type != :host_only
+
             if net_options[:name]
               return ni.name if net_options[:name] == ni.name
             else

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

@@ -10,6 +10,8 @@ module Vagrant
         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)

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

@@ -2,10 +2,34 @@ module Vagrant
   module Actions
     module VM
       class SharedFolders < Base
+        # This method returns an actual list of VirtualBox shared
+        # folders to create and their proper path.
         def shared_folders
-          @runner.env.config.vm.shared_folders.inject([]) do |acc, data|
-            name, value = data
-            acc << [name, File.expand_path(value[:hostpath], @runner.env.root_path), value[:guestpath], value[:syncpath]].compact
+          runner.env.config.vm.shared_folders.inject({}) do |acc, data|
+            key, value = data
+
+            # This to prevent overwriting the actual shared folders data
+            value = value.dup
+
+            if value[:sync]
+              # Syncing this folder. Change the guestpath to reflect
+              # what we're actually mounting.
+              value[:original] = value.dup
+              value[:guestpath] = "#{value[:guestpath]}#{runner.env.config.unison.folder_suffix}"
+            end
+
+            acc[key] = value
+            acc
+          end
+        end
+
+        # This method returns the list of shared folders which are to
+        # be synced via unison.
+        def unison_folders
+          shared_folders.inject({}) do |acc, data|
+            key, value = data
+            acc[key] = value if !!value[:sync]
+            acc
           end
         end
 
@@ -15,17 +39,30 @@ module Vagrant
         end
 
         def after_boot
+          mount_shared_folders
+          setup_unison
+        end
+
+        def mount_shared_folders
           logger.info "Mounting shared folders..."
 
           @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
+            shared_folders.each do |name, data|
+              logger.info "-- #{name}: #{data[:guestpath]}"
+              @runner.system.mount_shared_folder(ssh, name, data[:guestpath])
+            end
+          end
+        end
+
+        def setup_unison
+          return if unison_folders.empty?
+
+          runner.ssh.execute do |ssh|
+            runner.system.prepare_unison(ssh)
+
+            logger.info "Creating unison crontab entries..."
+            unison_folders.each do |name, data|
+              runner.system.create_unison(ssh, data)
             end
           end
         end
@@ -46,10 +83,10 @@ module Vagrant
         def create_metadata
           logger.info "Creating shared folders metadata..."
 
-          shared_folders.each do |name, hostpath, guestpath|
+          shared_folders.each do |name, data|
             folder = VirtualBox::SharedFolder.new
             folder.name = name
-            folder.host_path = hostpath
+            folder.host_path = File.expand_path(data[:hostpath], runner.env.root_path)
             @runner.vm.shared_folders << folder
           end
 

data/lib/vagrant/config.rb

@@ -77,6 +77,14 @@ module Vagrant
       end
     end
 
+    class UnisonConfig < Base
+      attr_accessor :folder_suffix
+      attr_accessor :script
+      attr_accessor :options
+      attr_accessor :crontab_entry_file
+      attr_accessor :log_file
+    end
+
     class VMConfig < Base
       include Util::StackedProcRunner
 
@@ -85,10 +93,6 @@ module Vagrant
       attr_accessor :box_ovf
       attr_accessor :base_mac
       attr_accessor :boot_mode
-      attr_accessor :sync_opts
-      attr_accessor :sync_script
-      attr_accessor :sync_crontab_entry_file
-      attr_reader :sync_required
       attr_reader :forwarded_ports
       attr_reader :shared_folders
       attr_reader :network_options
@@ -128,19 +132,11 @@ module Vagrant
         forwarded_ports[name] = options
       end
 
-      def share_folder(name, guestpath, hostpath = nil, opts = {})
-        guestpath, opts[:sync] = shift(guestpath, opts[:sync])
-
-        # TODO if both are nil the exception information will be unusable
-        if opts[:sync] == guestpath
-          raise Exception.new("The sync directory #{opts[:sync]} is identical to the shifted shared folder mount point #{guestpath}")
-        end
-
+      def share_folder(name, guestpath, hostpath, opts=nil)
         @shared_folders[name] = {
-          :syncpath => opts[:sync],
           :guestpath => guestpath,
           :hostpath => hostpath
-        }
+        }.merge(opts || {})
       end
 
       def network(ip, options=nil)
@@ -185,15 +181,6 @@ module Vagrant
         defined_vms[name.to_sym].options.merge!(options)
         defined_vms[name.to_sym].push_proc(&block)
       end
-
-      def shift(orig, sync)
-        if sync
-          @sync_required = true
-          [orig + '-sync', sync == true ? orig : sync]
-        else
-          [orig, sync]
-        end
-      end
     end
 
     class PackageConfig < Base
@@ -228,6 +215,7 @@ module Vagrant
       # Setup default configures
       configures :package, PackageConfig
       configures :ssh, SSHConfig
+      configures :unison, UnisonConfig
       configures :vm, VMConfig
       configures :vagrant, VagrantConfig
 

data/lib/vagrant/environment.rb

@@ -40,7 +40,7 @@ module Vagrant
         version = VirtualBox.version
         if version.nil?
           error_and_exit(:virtualbox_not_detected)
-        elsif version.to_f < 3.1
+        elsif version.to_f < 3.2
           error_and_exit(:virtualbox_invalid_version, :version => version.to_s)
         elsif version.to_s.downcase.include?("ose")
           error_and_exit(:virtualbox_invalid_ose, :version => version.to_s)

data/lib/vagrant/ssh.rb

@@ -24,6 +24,7 @@ module Vagrant
       end
 
       options = {}
+      options[:port] = port(opts)
       [:host, :username, :private_key_path].each do |param|
         options[param] = opts[param] || env.config.ssh.send(param)
       end
@@ -35,7 +36,7 @@ module Vagrant
       # we simply exec.
       pid = nil
       pid = fork if Util::Platform.leopard?
-      Kernel.exec "ssh -p #{port(opts)} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{options[:private_key_path]} #{options[:username]}@#{options[:host]}".strip if pid.nil?
+      Kernel.exec "ssh -p #{options[:port]} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{options[:private_key_path]} #{options[:username]}@#{options[:host]}".strip if pid.nil?
       Process.wait(pid) if pid
     end
 
@@ -132,20 +133,13 @@ module Vagrant
       return pnum if pnum
 
       # Check if we have an SSH forwarded port
-      if VirtualBox.version =~ /^3\.1\./
-        pnum = env.vm.vm.forwarded_ports.detect do |fp|
+      pnum = nil
+      env.vm.vm.network_adapters.each do |na|
+        pnum = na.nat_driver.forwarded_ports.detect do |fp|
           fp.name == env.config.ssh.forwarded_port_key
         end
-      else
-        # VirtualBox 3.2 specific
-        pnum = nil
-        env.vm.vm.network_adapters.each do |na|
-          pnum = na.nat_driver.forwarded_ports.detect do |fp|
-            fp.name == env.config.ssh.forwarded_port_key
-          end
 
-          break if pnum
-        end
+        break if pnum
       end
 
       return pnum.hostport if pnum

data/lib/vagrant/systems/base.rb

@@ -55,6 +55,13 @@ module Vagrant
       #   wants the folder mounted.
       def mount_shared_folder(ssh, name, guestpath); end
 
+      # Prepares the system for unison folder syncing. This is called
+      # once once prior to any `create_unison` calls.
+      def prepare_unison(ssh); end
+
+      # Creates an entry for folder syncing via unison.
+      def create_unison(ssh, options); end
+
       # Prepares the system for host only networks. This is called
       # once prior to any `enable_host_only_network` calls.
       def prepare_host_only_network; end

data/lib/vagrant/systems/linux.rb

@@ -17,7 +17,7 @@ module Vagrant
         attr_accessor :halt_check_interval
 
         def initialize
-          @halt_timeout = 15
+          @halt_timeout = 30
           @halt_check_interval = 1
         end
       end
@@ -49,24 +49,31 @@ module Vagrant
       def mount_shared_folder(ssh, name, guestpath)
         ssh.exec!("sudo mkdir -p #{guestpath}")
         mount_folder(ssh, name, guestpath)
-        chown(ssh, guestpath)
+        ssh.exec!("sudo chown #{config.ssh.username} #{guestpath}")
       end
 
-      def create_sync(ssh, opts)
-        crontab_entry = render_crontab_entry(opts.merge(:syncopts => config.vm.sync_opts,
-                                                        :scriptname => config.vm.sync_script))
+      def prepare_unison(ssh)
+        ssh.exec!("which unison", :error_key => :unison_not_found)
 
-        ssh.exec!("sudo mkdir -p #{opts[:syncpath]}")
-        chown(ssh, opts[:syncpath])
-        ssh.exec!("sudo echo \"#{crontab_entry}\" >> #{config.vm.sync_crontab_entry_file}")
-        ssh.exec!("crontab #{config.vm.sync_crontab_entry_file}")
+        logger.info "Preparing system for unison sync..."
+        vm.ssh.upload!(StringIO.new(TemplateRenderer.render('/unison/script')), config.unison.script)
+        ssh.exec!("sudo chmod +x #{config.unison.script}")
+        ssh.exec!("sudo rm #{config.unison.crontab_entry_file}", :error_check => false)
       end
 
-      def prepare_sync(ssh)
-        logger.info "Preparing system for sync..."
-        vm.ssh.upload!(StringIO.new(render_sync), config.vm.sync_script)
-        ssh.exec!("sudo chmod +x #{config.vm.sync_script}")
-        ssh.exec!("sudo rm #{config.vm.sync_crontab_entry_file}", :error_check => false)
+      def create_unison(ssh, opts)
+        sanitized_string = opts[:original][:guestpath].gsub(/[^a-zA-Z0-9_-]/, '-')
+        crontab_entry = TemplateRenderer.render('/unison/crontab_entry',
+                                                :from => opts[:guestpath],
+                                                :to => opts[:original][:guestpath],
+                                                :options => config.unison.options,
+                                                :script => config.unison.script,
+                                                :log_file => (config.unison.log_file % sanitized_string))
+
+        ssh.exec!("sudo rm -rf ~/.unison")
+        ssh.exec!("sudo rm -rf #{opts[:original][:guestpath]}")
+        ssh.exec!("sudo echo \"#{crontab_entry}\" >> #{config.unison.crontab_entry_file}")
+        ssh.exec!("crontab #{config.unison.crontab_entry_file}")
       end
 
       def prepare_host_only_network
@@ -117,21 +124,9 @@ module Vagrant
         end
       end
 
-      def chown(ssh, dir)
-        ssh.exec!("sudo chown #{config.ssh.username} #{dir}")
-      end
-
       def config
         vm.env.config
       end
-
-      def render_sync
-        TemplateRenderer.render('sync')
-      end
-
-      def render_crontab_entry(opts)
-        TemplateRenderer.render('crontab_entry', opts)
-      end
     end
   end
 end