vagrantup 0.1.4 → 0.2.0

data/lib/vagrant/downloaders/base.rb

@@ -5,6 +5,9 @@ module Vagrant
     class Base
       include Vagrant::Util
 
+      # Called prior to execution so any error checks can be done
+      def prepare(source_url); end
+
       # Downloads the source file to the destination file. It is up to
       # implementors of this class to handle the logic.
       def download!(source_url, destination_file); end

data/lib/vagrant/downloaders/file.rb

@@ -3,19 +3,19 @@ module Vagrant
     # "Downloads" a file to a temporary file. Basically, this downloader
     # simply does a file copy.
     class File < Base
-      BUFFERSIZE = 1048576 # 1 MB
+      def prepare(source_url)
+        if !::File.file?(source_url)
+          raise Actions::ActionException.new(<<-msg)
+The given box does not exist on the file system:
 
-      def download!(source_url, destination_file)
-        # For now we read the contents of one into a buffer
-        # and copy it into the other. In the future, we should do
-        # a system-level file copy (FileUtils.cp).
-        open(source_url) do |f|
-          loop do
-            break if f.eof?
-            destination_file.write(f.read(BUFFERSIZE))
-          end
+#{source_url}
+msg
         end
       end
+
+      def download!(source_url, destination_file)
+        FileUtils.cp(source_url, destination_file.path)
+      end
     end
   end
-end
+end

data/lib/vagrant/env.rb

@@ -24,21 +24,52 @@ module Vagrant
         load_config!
         load_home_directory!
         load_box!
+        load_config!
+        check_virtualbox!
         load_vm!
       end
 
+      def check_virtualbox!
+        version = VirtualBox::Command.version
+        if version.nil?
+          error_and_exit(<<-msg)
+Vagrant could not detect VirtualBox! Make sure VirtualBox is properly installed.
+If VirtualBox is installed, you may need to tweak the paths to the `VBoxManage`
+application which ships with VirtualBox and the path to the global XML configuration
+which VirtualBox typically stores somewhere in your home directory.
+
+The following shows how to configure VirtualBox. This can be done in the
+Vagrantfile. Note that 90% of the time, you shouldn't need to do this if VirtualBox
+is installed. Please use the various Vagrant support lines to request more information
+if you can't get this working.
+
+VirtualBox::Command.vboxmanage = "/path/to/my/VBoxManage"
+VirtualBox::Global.vboxconfig = "~/path/to/VirtualBox.xml"
+msg
+        elsif version.to_f < 3.1
+          error_and_exit(<<-msg)
+Vagrant has detected that you have VirtualBox version #{version} installed!
+Vagrant requires that you use at least VirtualBox version 3.1. Please install
+a more recent version of VirtualBox to continue.
+msg
+        end
+      end
+
       def load_config!
         # Prepare load paths for config files
         load_paths = [File.join(PROJECT_ROOT, "config", "default.rb")]
         load_paths << File.join(box.directory, ROOTFILE_NAME) if box
+        load_paths << File.join(home_path, ROOTFILE_NAME) if Vagrant.config.vagrant.home
         load_paths << File.join(root_path, ROOTFILE_NAME) if root_path
 
         # Then clear out the old data
         Config.reset!
 
         load_paths.each do |path|
-          logger.info "Loading config from #{path}..."
-          load path if File.exist?(path)
+          if File.exist?(path)
+            logger.info "Loading config from #{path}..."
+            load path
+          end
         end
 
         # Execute the configurations
@@ -63,11 +94,6 @@ module Vagrant
         return unless root_path
 
         @@box = Box.find(Vagrant.config.vm.box) if Vagrant.config.vm.box
-
-        if @@box
-          logger.info("Reloading configuration to account for loaded box...")
-          load_config!
-        end
       end
 
       def load_vm!
@@ -81,18 +107,28 @@ module Vagrant
       end
 
       def persist_vm(vm)
+        # Save to the dotfile for this project
         File.open(dotfile_path, 'w+') do |f|
           f.write(vm.uuid)
         end
+
+        # Also add to the global store
+        ActiveList.add(vm)
+      end
+
+      def depersist_vm(vm)
+        # Delete the dotfile if it exists
+        File.delete(dotfile_path) if File.exist?(dotfile_path)
+
+        # Remove from the global store
+        ActiveList.remove(vm)
       end
 
       def load_root_path!(path=nil)
-        path ||= Pathname.new(Dir.pwd)
+        path = Pathname.new(File.expand_path(path || Dir.pwd))
 
-        # Stop if we're at the root. 2nd regex matches windows drives
-        # such as C:. and Z:. Portability of this check will need to be
-        # researched.
-        return false if path.to_s == '/' || path.to_s =~ /^[A-Z]:\.$/
+        # Stop if we're at the root.
+        return false if path.root?
 
         file = "#{path}/#{ROOTFILE_NAME}"
         if File.exist?(file)

data/lib/vagrant/provisioners/base.rb

@@ -0,0 +1,22 @@
+module Vagrant
+  module Provisioners
+    # The base class for a "provisioner." A provisioner is responsible for
+    # provisioning a Vagrant system. This has been abstracted out to provide
+    # support for multiple solutions such as Chef Solo, Chef Client, and
+    # Puppet.
+    class Base
+      include Vagrant::Util
+
+      # This is the method called to "prepare" the provisioner. This is called
+      # before any actions are run by the action runner (see {Vagrant::Actions::Runner}).
+      # This can be used to setup shared folders, forward ports, etc. Whatever is
+      # necessary on a "meta" level.
+      def prepare; end
+
+      # This is the method called to provision the system. This method
+      # is expected to do whatever necessary to provision the system (create files,
+      # SSH, etc.)
+      def provision!; end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef.rb

@@ -0,0 +1,102 @@
+module Vagrant
+  module Provisioners
+    # This class is a base class where the common functinality shared between
+    # chef-solo and chef-client provisioning are stored. This is **not an actual
+    # provisioner**. Instead, {ChefSolo} or {ChefServer} should be used.
+    class Chef < Base
+      # This is the configuration which is available through `config.chef`
+      class ChefConfig < Vagrant::Config::Base
+        # Chef server specific config
+        attr_accessor :chef_server_url
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+        attr_accessor :client_key_path
+
+        # Chef solo specific config
+        attr_accessor :cookbooks_path
+
+        # Shared config
+        attr_accessor :provisioning_path
+        attr_accessor :json
+
+        def initialize
+          @validation_client_name = "chef-validator"
+          @client_key_path = "/etc/chef/client.pem"
+
+          @cookbooks_path = "cookbooks"
+          @provisioning_path = "/tmp/vagrant-chef"
+          @json = {
+            :instance_role => "vagrant",
+            :run_list => ["recipe[vagrant_main]"]
+          }
+        end
+
+        # Returns the run list for the provisioning
+        def run_list
+          json[:run_list]
+        end
+
+        # Sets the run list to the specified value
+        def run_list=(value)
+          json[:run_list] = value
+        end
+
+        # Adds a recipe to the run list
+        def add_recipe(name)
+          name = "recipe[#{name}]" unless name =~ /^recipe\[(.+?)\]$/
+          run_list << name
+        end
+
+        # Adds a role to the run list
+        def add_role(name)
+          name = "role[#{name}]" unless name =~ /^role\[(.+?)\]$/
+          run_list << name
+        end
+
+        def to_json
+          # Overridden so that the 'json' key could be removed, since its just
+          # merged into the config anyways
+          data = instance_variables_hash
+          data.delete(:json)
+          data.to_json
+        end
+      end
+
+      # Tell the Vagrant configure class about our custom configuration
+      Config.configures :chef, ChefConfig
+
+      def prepare
+        raise Actions::ActionException.new("Vagrant::Provisioners::Chef is not a valid provisioner! Use ChefSolo or ChefServer instead.")
+      end
+
+      def chown_provisioning_folder
+        logger.info "Setting permissions on chef provisioning folder..."
+        SSH.execute do |ssh|
+          ssh.exec!("sudo mkdir -p #{Vagrant.config.chef.provisioning_path}")
+          ssh.exec!("sudo chown #{Vagrant.config.ssh.username} #{Vagrant.config.chef.provisioning_path}")
+        end
+      end
+
+      def setup_json
+        logger.info "Generating chef JSON and uploading..."
+
+        # Set up initial configuration
+        data = {
+          :config => Vagrant.config,
+          :directory => Vagrant.config.vm.project_directory,
+        }
+
+        # And wrap it under the "vagrant" namespace
+        data = { :vagrant => data }
+
+        # Merge with the "extra data" which isn't put under the
+        # vagrant namespace by default
+        data.merge!(Vagrant.config.chef.json)
+
+        json = data.to_json
+
+        SSH.upload!(StringIO.new(json), File.join(Vagrant.config.chef.provisioning_path, "dna.json"))
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef_server.rb

@@ -0,0 +1,96 @@
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-client, allowing provisioning
+    # with a chef server.
+    class ChefServer < Chef
+      def prepare
+        if Vagrant.config.chef.validation_key_path.nil?
+          raise Actions::ActionException.new(<<-msg)
+Chef server provisioning requires that the `config.chef.validation_key_path` configuration
+be set to a path on your local machine of the validation key used to register the
+VM with the chef server.
+msg
+        elsif !File.file?(Vagrant.config.chef.validation_key_path)
+          raise Actions::ActionException.new(<<-msg)
+The validation key set for `config.chef.validation_key_path` does not exist! This
+file needs to exist so it can be uploaded to the virtual machine. It is
+currently set to "#{Vagrant.config.chef.validation_key_path}"
+msg
+        end
+
+        if Vagrant.config.chef.chef_server_url.nil?
+          raise Actions::ActionException.new(<<-msg)
+Chef server provisioning requires that the `config.chef.chef_server_url` be set to the
+URL of your chef server. Examples include "http://12.12.12.12:4000" and
+"http://myserver.com:4000" (the port of course can be different, but 4000 is the default)
+msg
+        end
+      end
+
+      def provision!
+        chown_provisioning_folder
+        create_client_key_folder
+        upload_validation_key
+        setup_json
+        setup_config
+        run_chef_client
+      end
+
+      def create_client_key_folder
+        logger.info "Creating folder to hold client key..."
+        path = Pathname.new(Vagrant.config.chef.client_key_path)
+
+        SSH.execute do |ssh|
+          ssh.exec!("sudo mkdir -p #{path.dirname}")
+        end
+      end
+
+      def upload_validation_key
+        logger.info "Uploading chef client validation key..."
+        SSH.upload!(validation_key_path, guest_validation_key_path)
+      end
+
+      def setup_config
+        solo_file = <<-solo
+log_level          :info
+log_location       STDOUT
+ssl_verify_mode    :verify_none
+chef_server_url    "#{Vagrant.config.chef.chef_server_url}"
+
+validation_client_name "#{Vagrant.config.chef.validation_client_name}"
+validation_key         "#{guest_validation_key_path}"
+client_key             "#{Vagrant.config.chef.client_key_path}"
+
+file_store_path    "/srv/chef/file_store"
+file_cache_path    "/srv/chef/cache"
+
+pid_file           "/var/run/chef/chef-client.pid"
+
+Mixlib::Log::Formatter.show_time = true
+solo
+
+        logger.info "Uploading chef-client configuration script..."
+        SSH.upload!(StringIO.new(solo_file), File.join(Vagrant.config.chef.provisioning_path, "client.rb"))
+      end
+
+      def run_chef_client
+        logger.info "Running chef-client..."
+        SSH.execute do |ssh|
+          ssh.exec!("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-client -c client.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 validation_key_path
+        File.expand_path(Vagrant.config.chef.validation_key_path, Env.root_path)
+      end
+
+      def guest_validation_key_path
+        File.join(Vagrant.config.chef.provisioning_path, "validation.pem")
+      end
+    end
+  end
+end

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={})