vagrantup 0.4.1 → 0.4.3.dev

data/lib/vagrant/util/template_renderer.rb

@@ -76,7 +76,7 @@ module Vagrant
       #
       # @return [String]
       def full_template_path
-        File.join(PROJECT_ROOT, 'templates', "#{template}.erb")
+        File.join(PROJECT_ROOT, 'templates', "#{template}.erb").squeeze("/")
       end
     end
   end

data/templates/strings.yml

@@ -70,6 +70,12 @@
   A box with the name '<%= box_name %>' already exists, please use another name or use `vagrant box remove <%= box_name %>`
 :box_download_unknown_type: |-
   Unknown URI type for box download.
+:box_file_exists: |-
+  The specified output file for packaging already exists. Please move
+  the file or modify the output filename parameter then try to package
+  again.
+
+  Specified output file: <%= output_file %>
 :box_remove_doesnt_exist: |-
   The box you're attempting to remove does not exist!
 :box_specified_doesnt_exist: |-
@@ -136,6 +142,11 @@
   If the name specification is removed, Vagrant will create a new
   host only network for you. Alternatively, please create the
   specified network manually.
+:network_collides: |-
+  The specified host network collides with a non-hostonly network!
+  This will cause your specified IP to be inaccessible. Please change
+  the IP or name of your host only network to not match that of
+  a bridged or non-hostonly network.
 :package_include_file_doesnt_exist: |-
   File specified to include: '<%= filename %>' does not exist!
 :package_multivm: |-
@@ -212,6 +223,11 @@
 :system_unspecified: |-
   A VM system type must be specified! This is done via the `config.vm.system`
   configuration value. Please read the documentation online for more information.
+:unison_not_found: |-
+  The `unison` binary was not found on the guest machine. This is required
+  for folder syncing via unison. Please install unison on your system to
+  use folder syncing. You may also disable folder syncing, install unison,
+  re-enable syncing, then call a `vagrant reload` to enable syncing.
 :unknown_vm: |-
   The specified VM could not be found: <%= vm %>
 :virtualbox_import_failure: |-
@@ -219,7 +235,7 @@
   manually for more verbose error output.
 :virtualbox_invalid_version: |-
   Vagrant has detected that you have VirtualBox version <%= version %> installed!
-  Vagrant requires that you use at least VirtualBox version 3.1. Please install
+  Vagrant requires that you use at least VirtualBox version 3.2. Please install
   a more recent version of VirtualBox to continue.
 :virtualbox_not_detected: |-
   Vagrant could not detect VirtualBox! Make sure VirtualBox is properly installed.

data/templates/unison/crontab_entry.erb

@@ -0,0 +1 @@
+* * * * * <%= script %> '<%= from %>' '<%= to %>' '<%= options %>' >> <%= log_file %> 2>&1

data/templates/unison/script.erb

@@ -0,0 +1,71 @@
+#!/bin/bash
+#------------------------------------------------------------
+# Author       : John Bender and Mitchell Hashimoto
+# Description  : Runs the `unison` folder synchronization
+#                utility for shared folders.
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+# Argument verification
+#------------------------------------------------------------
+if [ $# -ne 3 ]; then
+    echo "Usage: `basename $0` from_folder to_folder options"
+    exit 1
+fi
+
+# Sanitization function which turns any non-alphanumeric char
+# into a dash '-' and returns it by echoing the result.
+function sanitize() {
+    local DATA=$1
+    DATA=${DATA//[^a-zA-Z0-9_-]/-}
+    echo ${DATA}
+}
+
+#------------------------------------------------------------
+# "Configuration"
+#------------------------------------------------------------
+# TODO Change lockfile to depend on the from/to folder to
+# allow multiple syncs of diff folders to happen at once.
+FROM=$1
+TO=$2
+OPTIONS=$3
+LOCK_FILE=`basename $0`-$(sanitize ${TO}).lck
+
+#------------------------------------------------------------
+# Am I Running?
+#------------------------------------------------------------
+if [ -f "${LOCK_FILE}" ]; then
+    # The file exists, verify its running and if so exit.
+    OUR_PID=`head -n 1 "${LOCK_FILE}"`
+    TEST_RUNNING=`ps -p ${OUR_PID} | grep ${OUR_PID}`
+
+    if [ "${TEST_RUNNING}" ]; then
+        # The process is running, echo and exit.
+        echo "Unison sync already running. [PID: ${OUR_PID}]"
+        exit 0
+    fi
+fi
+
+# We're not running if we reached this point, so lock
+# it up.
+echo $$ > "${LOCK_FILE}"
+
+#------------------------------------------------------------
+# The Meat
+#------------------------------------------------------------
+echo "Beginning Sync:"
+echo " -- From: ${FROM}"
+echo " -- To: ${TO}"
+echo " -- Options: ${OPTIONS}"
+while [ 1 ]; do
+  echo "Syncing: $(date)"
+  # TODO check result and output log data... somewhere!
+  sudo unison ${FROM} ${TO} ${OPTIONS}
+  sleep 1
+done
+
+#------------------------------------------------------------
+# Cleanup and Exit
+#------------------------------------------------------------
+rm -f "${LOCK_FILE}"
+exit 0

data/test/test_helper.rb

@@ -23,6 +23,7 @@ class Test::Unit::TestCase
     Vagrant::Config.reset!(environment)
 
     Vagrant::Config.run do |config|
+      config.vagrant.home = '~/.home'
       config.vagrant.dotfile_name = ".vagrant"
       config.vagrant.log_output = nil
 
@@ -42,13 +43,15 @@ class Test::Unit::TestCase
       config.vm.shared_folder_uid = nil
       config.vm.shared_folder_gid = nil
       config.vm.system = :linux
-      config.vm.sync_script = "/foo"
-      config.vm.sync_crontab_entry_file = "/tmp/foo"
       config.vm.share_folder("v-root", "/vagrant", ".")
 
       config.package.name = 'vagrant'
       config.package.extension = '.box'
 
+      # Unison
+      config.unison.folder_suffix = ".sync"
+      config.unison.log_file = "foo-%s"
+
       # Chef
       config.chef.chef_server_url = "http://localhost:4000"
       config.chef.validation_key_path = "validation.pem"
@@ -60,8 +63,6 @@ class Test::Unit::TestCase
       config.chef.json = {
         :recipes => ["vagrant_main"]
       }
-
-      config.vagrant.home = '~/.home'
     end
 
     if block_given?

data/test/vagrant/actions/vm/forward_ports_test.rb

@@ -103,9 +103,10 @@ class ForwardPortsActionTest < Test::Unit::TestCase
       forwarded_ports = mock("forwarded_ports")
       network_adapter = mock("network_adapter")
 
-      @vm.expects(:network_adapters).returns([network_adapter])
+      @vm.stubs(:network_adapters).returns([network_adapter])
       network_adapter.expects(:attachment_type).returns(:nat)
 
+      @action.expects(:forward_port).once
       @vm.expects(:save).once
       @runner.expects(:reload!).once
       @action.forward_ports
@@ -182,13 +183,6 @@ class ForwardPortsActionTest < Test::Unit::TestCase
       @action.used_ports
     end
 
-    should "return the forwarded ports for VB 3.1.x" do
-      VirtualBox.stubs(:version).returns("3.1.4")
-      fps = [mock_fp(2222), mock_fp(80)]
-      @vms << mock_vm(:forwarded_ports => fps)
-      assert_equal %W[2222 80], @action.used_ports
-    end
-
     should "return the forwarded ports for VB 3.2.x" do
       VirtualBox.stubs(:version).returns("3.2.4")
       fps = [mock_fp(2222), mock_fp(80)]
@@ -208,92 +202,52 @@ class ForwardPortsActionTest < Test::Unit::TestCase
       fp
     end
 
-    context "in VB 3.1.x" do
-      setup do
-        VirtualBox.stubs(:version).returns("3.1.4")
-        @fps = []
-        @vm.stubs(:forwarded_ports).returns(@fps)
-      end
-
-      should "destroy each forwarded port" do
-        @fps << mock_fp
-        @fps << mock_fp
-        @action.clear_ports
-      end
+    setup do
+      VirtualBox.stubs(:version).returns("3.2.8")
+      @adapters = []
+      @vm.stubs(:network_adapters).returns(@adapters)
     end
 
-    context "in VB 3.2.x" do
-      setup do
-        VirtualBox.stubs(:version).returns("3.2.8")
-        @adapters = []
-        @vm.stubs(:network_adapters).returns(@adapters)
-      end
-
-      def mock_adapter
-        na = mock("adapter")
-        engine = mock("engine")
-        engine.stubs(:forwarded_ports).returns([mock_fp])
-        na.stubs(:nat_driver).returns(engine)
-        na
-      end
+    def mock_adapter
+      na = mock("adapter")
+      engine = mock("engine")
+      engine.stubs(:forwarded_ports).returns([mock_fp])
+      na.stubs(:nat_driver).returns(engine)
+      na
+    end
 
-      should "destroy each forwarded port" do
-        @adapters << mock_adapter
-        @adapters << mock_adapter
-        @action.clear_ports
-      end
+    should "destroy each forwarded port" do
+      @adapters << mock_adapter
+      @adapters << mock_adapter
+      @action.clear_ports
     end
   end
 
-  context "forwarding ports" do
-    context "in VB 3.1.x" do
-      setup do
-        VirtualBox.stubs(:version).returns("3.1.4")
-      end
-
-      should "forward ports" do
-        forwarded_ports = mock("forwarded_ports")
-        @vm.expects(:forwarded_ports).returns(forwarded_ports)
-        @runner.env.config.vm.forwarded_ports.each do |name, opts|
-          forwarded_ports.expects(:<<).with do |port|
-            assert_equal name, port.name
-            assert_equal opts[:hostport], port.hostport
-            assert_equal opts[:guestport], port.guestport
-            assert_equal opts[:adapter], port.instance
-            true
-          end
-
-          @action.forward_port(name, opts)
-        end
+  context "forwarding ports implementation" do
+    setup do
+      VirtualBox.stubs(:version).returns("3.2.8")
+    end
+
+    should "forward ports" do
+      name, opts = @runner.env.config.vm.forwarded_ports.first
+
+      adapters = []
+      adapter = mock("adapter")
+      engine = mock("engine")
+      fps = mock("forwarded ports")
+      adapter.stubs(:nat_driver).returns(engine)
+      engine.stubs(:forwarded_ports).returns(fps)
+      fps.expects(:<<).with do |port|
+        assert_equal name, port.name
+        assert_equal opts[:hostport], port.hostport
+        assert_equal opts[:guestport], port.guestport
+        true
       end
-    end
 
-    context "in VB 3.2.x" do
-      setup do
-        VirtualBox.stubs(:version).returns("3.2.8")
-      end
+      adapters[opts[:adapter]] = adapter
+      @vm.stubs(:network_adapters).returns(adapters)
 
-      should "forward ports" do
-        name, opts = @runner.env.config.vm.forwarded_ports.first
-
-        adapters = []
-        adapter = mock("adapter")
-        engine = mock("engine")
-        fps = mock("forwarded ports")
-        adapter.stubs(:nat_driver).returns(engine)
-        engine.stubs(:forwarded_ports).returns(fps)
-        fps.expects(:<<).with do |port|
-          assert_equal name, port.name
-          assert_equal opts[:hostport], port.hostport
-          assert_equal opts[:guestport], port.guestport
-          true
-        end
-
-        adapters[opts[:adapter]] = adapter
-        @vm.stubs(:network_adapters).returns(adapters)
-
-        @action.forward_port(name, opts)
-      end
+      @action.forward_port(name, opts)
     end
   end
 end

data/test/vagrant/actions/vm/network_test.rb

@@ -4,6 +4,36 @@ class NetworkTest < Test::Unit::TestCase
   setup do
     @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Network)
     @runner.stubs(:system).returns(linux_system(@vm))
+
+    @interfaces = []
+    VirtualBox::Global.global.host.stubs(:network_interfaces).returns(@interfaces)
+  end
+
+  def mock_interface(options=nil)
+    options = {
+      :interface_type => :host_only,
+      :name => "foo"
+    }.merge(options || {})
+
+    interface = mock("interface")
+    options.each do |k,v|
+      interface.stubs(k).returns(v)
+    end
+
+    @interfaces << interface
+    interface
+  end
+
+  context "preparing" do
+    should "verify no bridge collisions for each network enabled" do
+      @runner.env.config.vm.network("foo")
+      @action.expects(:verify_no_bridge_collision).once.with() do |options|
+        assert_equal "foo", options[:ip]
+        true
+      end
+
+      @action.prepare
+    end
   end
 
   context "before destroy" do
@@ -112,11 +142,30 @@ class NetworkTest < Test::Unit::TestCase
     end
   end
 
-  context "network name" do
+  context "verify no bridge collision" do
     setup do
-      @interfaces = []
-      VirtualBox::Global.global.host.stubs(:network_interfaces).returns(@interfaces)
+      @action.stubs(:matching_network?).returns(false)
+      @options = { :ip => :foo, :netmask => :bar, :name => nil }
+    end
 
+    should "do nothing if everything is okay" do
+      mock_interface
+
+      assert_nothing_raised { @action.verify_no_bridge_collision(@options) }
+    end
+
+    should "raise an exception if a collision is found" do
+      mock_interface(:interface_type => :bridged)
+      @action.stubs(:matching_network?).returns(true)
+
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.verify_no_bridge_collision(@options)
+      }
+    end
+  end
+
+  context "network name" do
+    setup do
       @action.stubs(:matching_network?).returns(false)
 
       @options = { :ip => :foo, :netmask => :bar, :name => nil }
@@ -124,21 +173,26 @@ class NetworkTest < Test::Unit::TestCase
 
     should "return the network which matches" do
       result = mock("result")
-      interface = mock("interface")
-      interface.stubs(:name).returns(result)
-      @interfaces << interface
+      interface = mock_interface(:name => result)
 
       @action.expects(:matching_network?).with(interface, @options).returns(true)
       assert_equal result, @action.network_name(@options)
     end
 
-    should "return the network which matches the name if given" do
+    should "ignore non-host only interfaces" do
       @options[:name] = "foo"
+      mock_interface(:name => @options[:name],
+                     :interface_type => :bridged)
 
-      interface = mock("interface")
-      interface.stubs(:name).returns(@options[:name])
-      @interfaces << interface
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.network_name(@options)
+      }
+    end
+
+    should "return the network which matches the name if given" do
+      @options[:name] = "foo"
 
+      interface = mock_interface(:name => @options[:name])
       assert_equal @options[:name], @action.network_name(@options)
     end
 
@@ -154,12 +208,12 @@ class NetworkTest < Test::Unit::TestCase
 
     should "create a network for the IP and netmask" do
       result = mock("result")
-      interface = mock("interface")
       network_ip = :foo
+
+      interface = mock_interface(:name => result)
+      interface.expects(:enable_static).with(network_ip, @options[:netmask])
       @interfaces.expects(:create).returns(interface)
       @action.expects(:network_ip).with(@options[:ip], @options[:netmask]).once.returns(network_ip)
-      interface.expects(:enable_static).with(network_ip, @options[:netmask])
-      interface.expects(:name).returns(result)
 
       assert_equal result, @action.network_name(@options)
     end

data/test/vagrant/actions/vm/package_test.rb

@@ -226,6 +226,11 @@ class PackageActionTest < Test::Unit::TestCase
         @action.prepare
       end
 
+      should "raise an exception if the output file already exists" do
+        File.expects(:exist?).with(@action.tar_path).returns(false)
+        assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
+      end
+
       should "raise an exception when an include file does not exist" do
         File.expects(:exists?).once.returns(false)
         assert_raises(Vagrant::Actions::ActionException) { @action.prepare }