vagrant 0.1.4 → 0.2.0.pre

data/lib/vagrant/provisioners/chef_solo.rb

@@ -0,0 +1,67 @@
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-solo.
+    class ChefSolo < Chef
+      def prepare
+        share_cookbook_folders
+      end
+
+      def provision!
+        chown_provisioning_folder
+        setup_json
+        setup_solo_config
+        run_chef_solo
+      end
+
+      def share_cookbook_folders
+        host_cookbook_paths.each_with_index do |cookbook, i|
+          Vagrant.config.vm.share_folder("vagrant-chef-solo-#{i}", cookbook_path(i), cookbook)
+        end
+      end
+
+      def setup_solo_config
+        solo_file = <<-solo
+file_cache_path "#{Vagrant.config.chef.provisioning_path}"
+cookbook_path #{cookbooks_path}
+solo
+
+        logger.info "Uploading chef-solo configuration script..."
+        SSH.upload!(StringIO.new(solo_file), File.join(Vagrant.config.chef.provisioning_path, "solo.rb"))
+      end
+
+      def run_chef_solo
+        logger.info "Running chef-solo..."
+        SSH.execute do |ssh|
+          ssh.exec!("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json") do |channel, data, stream|
+            # TODO: Very verbose. It would be easier to save the data and only show it during
+            # an error, or when verbosity level is set high
+            logger.info("#{stream}: #{data}")
+          end
+        end
+      end
+
+      def host_cookbook_paths
+        cookbooks = Vagrant.config.chef.cookbooks_path
+        cookbooks = [cookbooks] unless cookbooks.is_a?(Array)
+        cookbooks.collect! { |cookbook| File.expand_path(cookbook, Env.root_path) }
+        return cookbooks
+      end
+
+      def cookbook_path(i)
+        File.join(Vagrant.config.chef.provisioning_path, "cookbooks-#{i}")
+      end
+
+      def cookbooks_path
+        result = []
+        host_cookbook_paths.each_with_index do |host_path, i|
+          result << cookbook_path(i)
+        end
+
+        # We're lucky that ruby's string and array syntax for strings is the
+        # same as JSON, so we can just convert to JSON here and use that
+        result = result.to_s if result.length == 1
+        result.to_json
+      end
+    end
+  end
+end

data/lib/vagrant/ssh.rb

@@ -1,19 +1,22 @@
 module Vagrant
   class SSH
-    SCRIPT = File.join(File.dirname(__FILE__), '..', '..', 'script', 'vagrant-ssh-expect.sh')
+    include Vagrant::Util
 
     class << self
       def connect(opts={})
         options = {}
-        [:host, :password, :username].each do |param|
+        [:host, :username, :private_key_path].each do |param|
           options[param] = opts[param] || Vagrant.config.ssh.send(param)
         end
 
-        Kernel.exec "#{SCRIPT} #{options[:username]} #{options[:password]} #{options[:host]} #{port(opts)}".strip
+        Kernel.exec "ssh -p #{port(opts)} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{options[:private_key_path]} #{options[:username]}@#{options[:host]}".strip
       end
 
-      def execute
-        Net::SSH.start(Vagrant.config.ssh.host, Vagrant.config[:ssh][:username], :port => port, :password => Vagrant.config[:ssh][:password]) do |ssh|
+      def execute(opts={})
+        Net::SSH.start(Vagrant.config.ssh.host,
+                       Vagrant.config[:ssh][:username],
+                       opts.merge( :port => port,
+                                   :keys => [Vagrant.config.ssh.private_key_path])) do |ssh|
           yield ssh
         end
       end
@@ -29,7 +32,7 @@ module Vagrant
         check_thread = Thread.new do
           begin
             Thread.current[:result] = false
-            Net::SSH.start(Vagrant.config.ssh.host, Vagrant.config.ssh.username, :port => port, :password => Vagrant.config.ssh.password, :timeout => Vagrant.config.ssh.timeout) do |ssh|
+            execute(:timeout => Vagrant.config.ssh.timeout) do |ssh|
               Thread.current[:result] = true
             end
           rescue Errno::ECONNREFUSED, Net::SSH::Disconnect
@@ -39,6 +42,22 @@ module Vagrant
 
         check_thread.join(Vagrant.config.ssh.timeout)
         return check_thread[:result]
+      rescue Net::SSH::AuthenticationFailed
+        error_and_exit(<<-msg)
+SSH authentication failed! While this could be due to a variety of reasons,
+the two most common are: private key path is incorrect or you're using a box
+which was built for Vagrant 0.1.x.
+
+Vagrant 0.2.x dropped support for password-based authentication. If you're
+tring to `vagrant up` a box which does not support Vagrant's private/public
+keypair, then this error will be raised. To resolve this, read the guide
+on converting base boxes from password-based to keypairs here:
+
+http://vagrantup.com/docs/converting_password_to_key_ssh.html
+
+If the box was built for 0.2.x and contains a custom public key, perhaps
+the path to the private key is incorrect. Check your `config.ssh.private_key_path`.
+msg
       end
 
       def port(opts={})

data/lib/vagrant/stacked_proc_runner.rb

@@ -0,0 +1,33 @@
+module Vagrant
+  # Represents the "stacked proc runner" behavior which is used a
+  # couple places within Vagrant. This allows procs to "stack" on
+  # each other, then all execute in a single action. An example of
+  # its uses can be seen in the {Config} class.
+  module StackedProcRunner
+    # Returns the proc stack. This should always be called as the
+    # accessor of the stack. The instance variable itself should _never_
+    # be used.
+    #
+    # @return [Array<Proc>]
+    def proc_stack
+      @_proc_stack ||= []
+    end
+
+    # Adds (pushes) a proc to the stack. The actual proc added here is
+    # not executed, but merely stored.
+    #
+    # @param [Proc] block
+    def push_proc(&block)
+      proc_stack << block
+    end
+
+    # Executes all the procs on the stack, passing in the given arguments.
+    # The stack is not cleared afterwords. It is up to the user of this
+    # mixin to clear the stack by calling `proc_stack.clear`.
+    def run_procs!(*args)
+      proc_stack.each do |proc|
+        proc.call(*args)
+      end
+    end
+  end
+end

data/lib/vagrant/vm.rb

@@ -19,6 +19,14 @@ module Vagrant
       @vm = vm
     end
 
+    def uuid
+      vm ? vm.uuid : nil
+    end
+
+    def reload!
+      @vm = VirtualBox::VM.find(@vm.uuid)
+    end
+
     def package(out_path, include_files=[])
       add_action(Actions::VM::Export)
       add_action(Actions::VM::Package, out_path, include_files)

data/lib/vagrant.rb

@@ -1,14 +1,19 @@
 libdir = File.dirname(__FILE__)
-$:.unshift(libdir)
 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
-  net/scp fileutils vagrant/util vagrant/actions/base vagrant/downloaders/base vagrant/actions/runner}.each do |f|
-  require f
+  net/scp fileutils}.each do |lib|
+  require lib
+end
+
+# The vagrant specific files which must be loaded prior to the rest
+%w{vagrant/util vagrant/stacked_proc_runner vagrant/actions/base vagrant/downloaders/base vagrant/actions/collection
+  vagrant/actions/runner vagrant/config vagrant/provisioners/base vagrant/provisioners/chef}.each do |f|
+  require File.expand_path(f, libdir)
 end
 
 # Glob require the rest
-Dir[File.join(PROJECT_ROOT, "lib", "vagrant", "**", "*.rb")].each do |f|
-  require f
+Dir[File.join(libdir, "vagrant", "**", "*.rb")].each do |f|
+  require File.expand_path(f)
 end

data/test/test_helper.rb

@@ -20,11 +20,10 @@ require 'mocha'
 class Test::Unit::TestCase
   # Clears the previous config and sets up the new config
   def mock_config
-    Vagrant::Config.instance_variable_set(:@config_runners, nil)
-    Vagrant::Config.instance_variable_set(:@config, nil)
+    Vagrant::Config.reset!
 
     Vagrant::Config.run do |config|
-      config.vagrant.dotfile_name = ".hobo"
+      config.vagrant.dotfile_name = ".vagrant"
 
       config.ssh.username = "foo"
       config.ssh.password = "bar"
@@ -32,21 +31,28 @@ class Test::Unit::TestCase
       config.ssh.forwarded_port_key = "ssh"
       config.ssh.max_tries = 10
       config.ssh.timeout = 10
+      config.ssh.private_key_path = '~/foo'
 
       config.vm.box = "foo"
       config.vm.box_ovf = "box.ovf"
       config.vm.base_mac = "42"
-      config.vm.project_directory = "/hobo"
+      config.vm.project_directory = "/vagrant"
       config.vm.disk_image_format = 'VMDK'
       config.vm.forward_port("ssh", 22, 2222)
+      config.vm.shared_folder_uid = nil
+      config.vm.shared_folder_gid = nil
 
       config.package.name = 'vagrant'
       config.package.extension = '.box'
 
+      # Chef
+      config.chef.chef_server_url = "http://localhost:4000"
+      config.chef.validation_key_path = "validation.pem"
+      config.chef.client_key_path = "/zoo/foo/bar.pem"
       config.chef.cookbooks_path = "cookbooks"
-      config.chef.provisioning_path = "/tmp/hobo-chef"
+      config.chef.provisioning_path = "/tmp/vagrant-chef"
       config.chef.json = {
-        :recipes => ["hobo_main"]
+        :recipes => ["vagrant_main"]
       }
 
       config.vagrant.home = '~/.home'
@@ -72,6 +78,7 @@ class Test::Unit::TestCase
     vm = mock("vboxvm")
     mock_vm = mock("vm")
     action = action_klass.new(mock_vm, *args)
+    stub_default_action_dependecies(action)
 
     mock_vm.stubs(:vm).returns(vm)
     mock_vm.stubs(:vm=)
@@ -82,6 +89,11 @@ class Test::Unit::TestCase
     [mock_vm, vm, action]
   end
 
+  def stub_default_action_dependecies(mock, klass=MockAction)
+    mock.stubs(:precedes).returns([])
+    mock.stubs(:follows).returns([])
+  end
+
   # Sets up the mocks and stubs for a downloader
   def mock_downloader(downloader_klass)
     tempfile = mock("tempfile")
@@ -90,3 +102,7 @@ class Test::Unit::TestCase
     [downloader_klass.new, tempfile]
   end
 end
+
+class MockAction; end
+class MockActionOther; end
+

data/test/vagrant/actions/collection_test.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CollectionTest < Test::Unit::TestCase
+  context "checking uniqueness" do
+    setup do
+      @actions = Vagrant::Actions::Collection.new([1])
+    end
+
+    should "return true if there are duplicate classes in the collection" do
+      @actions << 1
+      assert @actions.duplicates?
+    end
+    
+    should "return false it all the classes are unique" do
+      @actions << 1.0 << "foo"
+      assert !@actions.duplicates?
+    end
+
+    should "raise an exception when there are duplicates" do
+      @actions << 1 
+      assert_raise Vagrant::Actions::DuplicateActionException do
+        @actions.duplicates!
+      end
+    end
+
+    should "not raise an exception when there are no duplicates" do
+      @actions << 1.0 << "foo"
+      assert_nothing_raised do
+        @actions.duplicates!
+      end
+    end
+  end
+
+  context "verifying dependencies" do
+    setup do
+      @mock_action = mock('action')
+      @mock_action.stubs(:class).returns(MockAction)
+
+      @mock_action2 = mock('action2')
+      @mock_action2.stubs(:class).returns(MockActionOther)
+      # see test_helper
+      stub_default_action_dependecies(@mock_action)
+      stub_default_action_dependecies(@mock_action2)
+    end
+    
+    context "that come before an action" do
+      setup do
+        @mock_action.stubs(:follows).returns([MockActionOther])
+      end
+      should "raise an exception if they are not met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action]).dependencies!
+        end
+      end
+    
+      should "not raise an exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action2, @mock_action]).dependencies!
+        end
+      end
+    end
+
+    context "that follow an an action" do
+      setup do
+        @mock_action.stubs(:precedes).returns([MockActionOther])
+      end
+
+      should "raise an exception if they are not met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action]).dependencies!
+        end
+      end
+
+      should "not raise an exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action, @mock_action2]).dependencies!
+        end
+      end
+    end
+
+    context "that are before and after an action" do
+      setup do
+        @mock_action.stubs(:precedes).returns([MockActionOther])
+        @mock_action.stubs(:follows).returns([MockActionOther])
+      end
+
+      should "raise an exception if they are met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action2, @mock_action]).dependencies!
+        end
+      end
+
+      should "not raise and exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action2, @mock_action, @mock_action2]).dependencies!
+        end
+      end
+    end
+  end
+  
+  context "klasses" do
+    should "return a list of the collection element's classes" do
+      @action = mock('action')
+      assert_equal collection.new([@action]).klasses, [@action.class]
+      assert_equal collection.new([@action, 1.0, "foo"]).klasses, [@action.class, Float, String]
+    end
+  end
+
+  def collection; Vagrant::Actions::Collection end
+end

data/test/vagrant/actions/runner_test.rb

@@ -6,6 +6,7 @@ class ActionRunnerTest < Test::Unit::TestCase
     action.stubs(:prepare)
     action.stubs(:execute!)
     action.stubs(:cleanup)
+    stub_default_action_dependecies(action)
     action
   end
 
@@ -135,6 +136,7 @@ class ActionRunnerTest < Test::Unit::TestCase
     should "clear the actions and run a single action if given to execute!" do
       action = mock("action")
       run_action = mock("action_run")
+      stub_default_action_dependecies(run_action)
       run_class = mock("run_class")
       run_class.expects(:new).once.returns(run_action)
       @runner.actions << action
@@ -148,7 +150,6 @@ class ActionRunnerTest < Test::Unit::TestCase
     end
 
     should "clear actions after running execute!" do
-      @runner.actions << mock_fake_action
       @runner.actions << mock_fake_action
       assert !@runner.actions.empty? # sanity
       @runner.execute!
@@ -158,9 +159,10 @@ class ActionRunnerTest < Test::Unit::TestCase
     should "run #prepare on all actions, then #execute!" do
       action_seq = sequence("action_seq")
       actions = []
-      5.times do |i|
+      [MockAction, MockActionOther].each_with_index do |klass, i|
         action = mock("action#{i}")
-
+        action.expects(:class).returns(klass)
+        stub_default_action_dependecies(action, klass)
         @runner.actions << action
         actions << action
       end
@@ -176,10 +178,12 @@ class ActionRunnerTest < Test::Unit::TestCase
 
     context "exceptions" do
       setup do
-        @actions = [mock_fake_action, mock_fake_action]
-        @actions.each do |a|
-          a.stubs(:rescue)
-          @runner.actions << a
+        @actions = [MockAction, MockActionOther].map do |klass|
+          action = mock_fake_action
+          action.expects(:class).returns(klass)
+          action.stubs(:rescue)
+          @runner.actions << action
+          action
         end
 
         @exception = Exception.new

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

@@ -7,6 +7,13 @@ class BootActionTest < Test::Unit::TestCase
     mock_config
   end
 
+  context "preparing" do
+    should "add the root shared folder" do
+      Vagrant.config.vm.expects(:share_folder).with("vagrant-root", Vagrant.config.vm.project_directory, Vagrant::Env.root_path).once
+      @action.prepare
+    end
+  end
+
   context "execution" do
     should "invoke the 'boot' around callback" do
       boot_seq = sequence("boot_seq")
@@ -45,11 +52,4 @@ class BootActionTest < Test::Unit::TestCase
       assert !@action.wait_for_boot(0)
     end
   end
-
-  context "callbacks" do
-    should "setup the root directory shared folder" do
-      expected = ["vagrant-root", Vagrant::Env.root_path, Vagrant.config.vm.project_directory]
-      assert_equal expected, @action.collect_shared_folders
-    end
-  end
 end

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

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class CustomizeActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Customize)
+    mock_config
+  end
+
+  context "executing" do
+    should "run the VM customization procs then save the VM" do
+      Vagrant.config.vm.expects(:run_procs!).with(@vm)
+      @vm.expects(:save).with(true).once
+      @action.execute!
+    end
+  end
+end

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

@@ -2,23 +2,36 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 
 class DestroyActionTest < Test::Unit::TestCase
   setup do
-    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Destroy)
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Destroy)
     mock_config
   end
 
   context "executing" do
-    setup do
-      @vm.stubs(:destroy)
+    should "invoke an around callback around the destroy" do
+      @runner.expects(:invoke_around_callback).with(:destroy).once
+      @action.execute!
     end
 
-    should "invoke an around callback around the destroy" do
-      @mock_vm.expects(:invoke_around_callback).with(:destroy).once
+    should "destroy VM and clear persist" do
+      @runner.stubs(:invoke_around_callback).yields
+      clear_seq = sequence("clear")
+      @action.expects(:destroy_vm).in_sequence(clear_seq)
+      @action.expects(:depersist).in_sequence(clear_seq)
       @action.execute!
     end
+  end
 
+  context "destroying the VM" do
     should "destroy VM and attached images" do
       @vm.expects(:destroy).with(:destroy_image => true).once
-      @action.execute!
+      @action.destroy_vm
+    end
+  end
+
+  context "depersisting" do
+    should "call depersist_vm on Env" do
+      Vagrant::Env.expects(:depersist_vm).with(@runner).once
+      @action.depersist
     end
   end
 end

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

@@ -6,6 +6,58 @@ class ForwardPortsActionTest < Test::Unit::TestCase
     mock_config
   end
 
+  context "checking for colliding ports" do
+    setup do
+      @forwarded_port = mock("forwarded_port")
+      @forwarded_port.stubs(:hostport)
+      @forwarded_ports = [@forwarded_port]
+
+      @vm = mock("vm")
+      @vm.stubs(:forwarded_ports).returns(@forwarded_ports)
+      @vm.stubs(:running?).returns(true)
+      @vm.stubs(:uuid).returns("foo")
+      @mock_vm.stubs(:uuid).returns("bar")
+      vms = [@vm]
+      VirtualBox::VM.stubs(:all).returns(vms)
+
+      mock_config do |config|
+        config.vm.forwarded_ports.clear
+        config.vm.forward_port("ssh", 22, 2222)
+      end
+    end
+
+    should "ignore vms which aren't running" do
+      @vm.expects(:running?).returns(false)
+      @vm.expects(:forwarded_ports).never
+      @action.prepare
+    end
+
+    should "ignore vms which are equivalent to ours" do
+      @mock_vm.expects(:uuid).returns(@vm.uuid)
+      @vm.expects(:forwarded_ports).never
+      @action.prepare
+    end
+
+    should "not raise any errors if no forwarded ports collide" do
+      @forwarded_port.expects(:hostport).returns(80)
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an ActionException if a port collides" do
+      @forwarded_port.expects(:hostport).returns(2222)
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "convert ports to strings prior to checking" do
+      @forwarded_port.expects(:hostport).returns("2222")
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+  end
+
   context "execution" do
     should "clear all previous ports and forward new ports" do
       exec_seq = sequence("exec_seq")

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

@@ -23,14 +23,21 @@ class ImportActionTest < Test::Unit::TestCase
   end
 
   should "call import on VirtualBox::VM with the proper base" do
-    VirtualBox::VM.expects(:import).once.with(@ovf_file)
-    @import.execute!
+    VirtualBox::VM.expects(:import).once.with(@ovf_file).returns("foo")
+    assert_nothing_raised { @import.execute! }
+  end
+
+  should "raise an exception if import is nil" do
+    @mock_vm.expects(:vm).returns(nil)
+    assert_raises(Vagrant::Actions::ActionException) {
+      @import.execute!
+    }
   end
 
   should "set the resulting VM as the VM of the Vagrant VM object" do
     new_vm = mock("new_vm")
     @mock_vm.expects(:vm=).with(new_vm).once
-    VirtualBox::VM.expects(:import).returns(new_vm)
+    VirtualBox::VM.expects(:import).returns(new_vm).returns("foo")
     @import.execute!
   end
 end