vagrant 0.7.8 → 0.8.1

data/lib/vagrant/errors.rb

@@ -148,6 +148,21 @@ module Vagrant
       error_key(:socket_error, "vagrant.downloaders.http")
     end
 
+    class DownloaderHTTPStatusError < VagrantError
+      status_code(51)
+      error_key(:status_error, "vagrant.downloaders.http")
+    end
+
+    class EnvironmentLockedError < VagrantError
+      status_code(52)
+      error_key(:environment_locked)
+    end
+
+    class HomeDirectoryMigrationFailed < VagrantError
+      status_code(53)
+      error_key(:home_dir_migration_failed)
+    end
+
     class ForwardPortAutolistEmpty < VagrantError
       status_code(27)
       error_key(:auto_empty, "vagrant.actions.vm.forward_ports")

data/lib/vagrant/provisioners.rb

@@ -2,7 +2,7 @@
 # as configuration classes right away with Vagrant.
 require 'vagrant/provisioners/base'
 require 'vagrant/provisioners/chef'
-require 'vagrant/provisioners/chef_server'
+require 'vagrant/provisioners/chef_client'
 require 'vagrant/provisioners/chef_solo'
 require 'vagrant/provisioners/puppet'
 require 'vagrant/provisioners/puppet_server'

data/lib/vagrant/provisioners/base.rb

@@ -58,6 +58,10 @@ module Vagrant
       # is expected to do whatever necessary to provision the system (create files,
       # SSH, etc.)
       def provision!; end
+
+      # This is the method called to when the system is being destroyed
+      # and allows the provisioners to engage in any cleanup tasks necessary.
+      def cleanup; end
     end
   end
 end

data/lib/vagrant/provisioners/chef.rb

@@ -59,7 +59,7 @@ module Vagrant
 
         # Merge with the "extra data" which isn't put under the
         # vagrant namespace by default
-        data.merge!(config.json)
+        data.merge!(config.merged_json)
 
         json = data.to_json
 
@@ -76,6 +76,8 @@ module Vagrant
     class Chef < Base
       # This is the configuration which is available through `config.chef`
       class Config < Vagrant::Config::Base
+        extend Util::Counter
+
         # Shared config
         attr_accessor :node_name
         attr_accessor :provisioning_path
@@ -90,11 +92,12 @@ module Vagrant
         attr_accessor :no_proxy
         attr_accessor :binary_path
         attr_accessor :binary_env
+        attr_accessor :run_list
 
         def initialize
-          @provisioning_path = "/tmp/vagrant-chef"
+          @provisioning_path = "/tmp/vagrant-chef-#{self.class.get_and_update_counter}"
           @log_level = :info
-          @json = { :instance_role => "vagrant" }
+          @json = {}
           @http_proxy = nil
           @http_proxy_user = nil
           @http_proxy_pass = nil
@@ -104,16 +107,15 @@ module Vagrant
           @no_proxy = nil
           @binary_path = nil
           @binary_env = nil
+          @run_list = []
         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
+        # This returns the json that is merged with the defaults and the
+        # user set data.
+        def merged_json
+          { :instance_role => "vagrant",
+            :run_list      => run_list
+          }.merge(json || {})
         end
 
         # Adds a recipe to the run list

data/lib/vagrant/provisioners/{chef_server.rb → chef_client.rb}

@@ -4,8 +4,8 @@ module Vagrant
   module Provisioners
     # This class implements provisioning via chef-client, allowing provisioning
     # with a chef server.
-    class ChefServer < Chef
-      register :chef_server
+    class ChefClient < Chef
+      register :chef_client
 
       class Config < Chef::Config
         attr_accessor :chef_server_url
@@ -34,7 +34,7 @@ module Vagrant
 
           errors.add(I18n.t("vagrant.config.chef.server_url_empty")) if !chef_server_url || chef_server_url.strip == ""
           errors.add(I18n.t("vagrant.config.chef.validation_key_path")) if !validation_key_path
-          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if json[:run_list] && run_list.empty?
+          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if run_list && run_list.empty?
         end
       end
 
@@ -68,7 +68,7 @@ module Vagrant
         env.ui.info I18n.t("vagrant.provisioners.chef.upload_validation_key")
         vm.ssh.upload!(validation_key_path, guest_validation_key_path)
       end
-      
+
       def upload_encrypted_data_bag_secret
         env.ui.info I18n.t("vagrant.provisioners.chef.upload_encrypted_data_bag_secret_key")
         vm.ssh.upload!(encrypted_data_bag_secret_key_path, config.encrypted_data_bag_secret)
@@ -107,7 +107,7 @@ module Vagrant
       def validation_key_path
         File.expand_path(config.validation_key_path, env.root_path)
       end
-      
+
       def encrypted_data_bag_secret_key_path
         File.expand_path(config.encrypted_data_bag_secret_key_path, env.root_path)
       end

data/lib/vagrant/provisioners/chef_solo.rb

@@ -24,14 +24,22 @@ module Vagrant
           super
 
           errors.add(I18n.t("vagrant.config.chef.cookbooks_path_empty")) if !cookbooks_path || [cookbooks_path].flatten.empty?
-          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if !json[:run_list] || run_list.empty?
+          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if !run_list || run_list.empty?
         end
       end
 
+      attr_reader :cookbook_folders
+      attr_reader :role_folders
+      attr_reader :data_bags_folders
+
       def prepare
-        share_cookbook_folders
-        share_role_folders
-        share_data_bags_folders
+        @cookbook_folders = expanded_folders(config.cookbooks_path)
+        @role_folders = expanded_folders(config.roles_path)
+        @data_bags_folders = expanded_folders(config.data_bags_path)
+
+        share_folders("csc", @cookbook_folders)
+        share_folders("csr", @role_folders)
+        share_folders("csdb", @data_bags_folders)
       end
 
       def provision!
@@ -42,25 +50,47 @@ module Vagrant
         run_chef_solo
       end
 
-      def share_cookbook_folders
-        host_cookbook_paths.each_with_index do |cookbook, i|
-          env.config.vm.share_folder("v-csc-#{i}", cookbook_path(i), cookbook, :nfs => config.nfs)
-        end
-      end
+      # Converts paths to a list of properly expanded paths with types.
+      def expanded_folders(paths)
+        # Convert the path to an array if it is a string or just a single
+        # path element which contains the folder location (:host or :vm)
+        paths = [paths] if paths.is_a?(String) || paths.first.is_a?(Symbol)
+
+        index = 0
+        paths.map do |path|
+          path = [:host, path] if !path.is_a?(Array)
+          type, path = path
+
+          # Create the local/remote path based on whether this is a host
+          # or VM path.
+          local_path = nil
+          local_path = File.expand_path(path, env.root_path) if type == :host
+          remote_path = type == :host ? "#{config.provisioning_path}/chef-solo-#{index}" : path
+          index += 1
 
-      def share_role_folders
-        host_role_paths.each_with_index do |role, i|
-          env.config.vm.share_folder("v-csr-#{i}", role_path(i), role, :nfs => config.nfs)
+          # Return the result
+          [type, local_path, remote_path]
         end
       end
 
-      def share_data_bags_folders
-        host_data_bag_paths.each_with_index do |data_bag, i|
-          env.config.vm.share_folder("v-csdb-#{i}", data_bag_path(i), data_bag, :nfs => config.nfs)
+      # Shares the given folders with the given prefix. The folders should
+      # be of the structure resulting from the `expanded_folders` function.
+      def share_folders(prefix, folders)
+        index = 0
+        folders.each do |type, local_path, remote_path|
+          if type == :host
+            env.config.vm.share_folder("v-#{prefix}-#{index}",
+                                       remote_path, local_path, :nfs => config.nfs)
+            index += 1
+          end
         end
       end
 
       def setup_solo_config
+        cookbooks_path = guest_paths(@cookbook_folders)
+        roles_path = guest_paths(@role_folders)
+        data_bags_path = guest_paths(@data_bags_folders)
+
         setup_config("chef_solo_solo", "solo.rb", {
           :node_name => config.node_name,
           :provisioning_path => config.provisioning_path,
@@ -87,80 +117,9 @@ module Vagrant
         end
       end
 
-      def host_folder_paths(paths)
-        # Convert single cookbook paths such as "cookbooks" or [:vm, "cookbooks"]
-        # into a proper array representation.
-        paths = [paths] if paths.is_a?(String) || paths.first.is_a?(Symbol)
-
-        paths.inject([]) do |acc, path|
-          path = [:host, path] if !path.is_a?(Array)
-          type, path = path
-
-          acc << File.expand_path(path, env.root_path) if type == :host
-          acc
-        end
-      end
-
-      def folder_path(*args)
-        File.join(config.provisioning_path, args.join("-"))
-      end
-
-      def folders_path(folders, folder)
-        # Convert single cookbook paths such as "cookbooks" or [:vm, "cookbooks"]
-        # into a proper array representation.
-        folders = [folders] if folders.is_a?(String) || folders.first.is_a?(Symbol)
-
-        # Convert each path to the proper absolute path depending on if the path
-        # is a host path or a VM path
-        result = []
-        folders.each_with_index do |path, i|
-          path = [:host, path] if !path.is_a?(Array)
-          type, path = path
-
-          result << folder_path(folder, i) if type == :host
-          result << folder_path(path) if type == :vm
-        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[0].to_s if result.length == 1
-        result
-      end
-
-      def host_cookbook_paths
-        host_folder_paths(config.cookbooks_path)
-      end
-
-      def host_role_paths
-        host_folder_paths(config.roles_path)
-      end
-
-      def host_data_bag_paths
-        host_folder_paths(config.data_bags_path)
-      end
-
-      def cookbook_path(i)
-        folder_path("cookbooks", i)
-      end
-
-      def role_path(i)
-        folder_path("roles", i)
-      end
-
-      def data_bag_path(i)
-        folder_path("data_bags", i)
-      end
-
-      def cookbooks_path
-        folders_path(config.cookbooks_path, "cookbooks").to_json
-      end
-
-      def roles_path
-        folders_path(config.roles_path, "roles").to_json
-      end
-
-      def data_bags_path
-        folders_path(config.data_bags_path, "data_bags").to_json
+      # Extracts only the remote paths from a list of folders
+      def guest_paths(folders)
+        folders.map { |parts| parts[2] }
       end
     end
   end

data/lib/vagrant/provisioners/shell.rb

@@ -4,10 +4,13 @@ module Vagrant
       register :shell
 
       class Config < Vagrant::Config::Base
+        attr_accessor :inline
         attr_accessor :path
         attr_accessor :upload_path
 
         def initialize
+          @inline = nil
+          @path = nil
           @upload_path = "/tmp/vagrant-shell"
         end
 
@@ -18,31 +21,63 @@ module Vagrant
         def validate(errors)
           super
 
-          if !path
-            errors.add(I18n.t("vagrant.provisioners.shell.path_not_set"))
-          elsif !expanded_path.file?
+          # Validate that the parameters are properly set
+          if path && inline
+            errors.add(I18n.t("vagrant.provisioners.shell.path_and_inline_set"))
+          elsif !path && !inline
+            errors.add(I18n.t("vagrant.provisioners.shell.no_path_or_inline"))
+          end
+
+          # Validate the existence of a script to upload
+          if path && !expanded_path.file?
             errors.add(I18n.t("vagrant.provisioners.shell.path_invalid", :path => expanded_path))
           end
 
+          # There needs to be a path to upload the script to
           if !upload_path
             errors.add(I18n.t("vagrant.provisioners.shell.upload_path_not_set"))
           end
         end
       end
 
+      # This method yields the path to a script to upload and execute
+      # on the remote server. This method will properly clean up the
+      # script file if needed.
+      def with_script_file
+        if config.path
+          # Just yield the path to that file...
+          yield config.expanded_path
+          return
+        end
+
+        # Otherwise we have an inline script, we need to Tempfile it,
+        # and handle it specially...
+        file = Tempfile.new('vagrant-shell')
+        begin
+          file.write(config.inline)
+          file.fsync
+          yield file.path
+        ensure
+          file.close
+          file.unlink
+        end
+      end
+
       def provision!
         commands = ["chmod +x #{config.upload_path}", config.upload_path]
 
-        # Upload the script to the VM
-        vm.ssh.upload!(config.expanded_path.to_s, config.upload_path)
+        with_script_file do |path|
+          # Upload the script to the VM
+          vm.ssh.upload!(path.to_s, config.upload_path)
 
-        # Execute it with sudo
-        vm.ssh.execute do |ssh|
-          ssh.sudo!(commands) do |ch, type, data|
-            if type == :exit_status
-              ssh.check_exit_status(data, commands)
-            else
-              env.ui.info(data)
+          # Execute it with sudo
+          vm.ssh.execute do |ssh|
+            ssh.sudo!(commands) do |ch, type, data|
+              if type == :exit_status
+                ssh.check_exit_status(data, commands)
+              else
+                env.ui.info(data)
+              end
             end
           end
         end

data/lib/vagrant/ssh.rb

@@ -1,16 +1,17 @@
-require 'timeout'
 require 'net/ssh'
 require 'net/scp'
-require 'mario'
-
-require 'vagrant/ssh/session'
 
 module Vagrant
   # Manages SSH access to a specific environment. Allows an environment to
   # replace the process with SSH itself, run a specific set of commands,
   # upload files, or even check if a host is up.
   class SSH
+    # Autoload this guy because he is really only used in one location
+    # and not for every Vagrant command.
+    autoload :Session, 'vagrant/ssh/session'
+
     include Util::Retryable
+    include Util::SafeExec
 
     # Reference back up to the environment which this SSH object belongs
     # to
@@ -18,13 +19,14 @@ module Vagrant
 
     def initialize(environment)
       @env = environment
+      @current_session = nil
     end
 
     # Connects to the environment's virtual machine, replacing the ruby
     # process with an SSH process. This method optionally takes a hash
     # of options which override the configuration values.
     def connect(opts={})
-      if Mario::Platform.windows?
+      if Util::Platform.windows?
         raise Errors::SSHUnavailableWindows, :key_path => env.config.ssh.private_key_path,
                                              :ssh_port => port(opts)
       end
@@ -54,10 +56,9 @@ module Vagrant
       # Some hackery going on here. On Mac OS X Leopard (10.5), exec fails
       # (GH-51). As a workaround, we fork and wait. On all other platforms,
       # we simply exec.
-      pid = nil
-      pid = fork if Util::Platform.leopard? || Util::Platform.tiger?
-      Kernel.exec "ssh #{command_options.join(" ")} #{options[:username]}@#{options[:host]}".strip if pid.nil?
-      Process.wait(pid) if pid
+      command = "ssh #{command_options.join(" ")} #{options[:username]}@#{options[:host]}".strip
+      env.logger.info("ssh") { "Invoking SSH: #{command}" }
+      safe_exec(command)
     end
 
     # Opens an SSH connection to this environment's virtual machine and yields
@@ -71,17 +72,37 @@ module Vagrant
       opts[:forward_agent] = true if env.config.ssh.forward_agent
       opts[:port] ||= port
 
-      retryable(:tries => 5, :on => Errno::ECONNREFUSED) do
-        Net::SSH.start(env.config.ssh.host,
-                       env.config.ssh.username,
-                       opts.merge( :keys => [env.config.ssh.private_key_path],
-                                   :keys_only => true,
-                                   :user_known_hosts_file => [],
-                                   :paranoid => false,
-                                   :config => false)) do |ssh|
-          yield SSH::Session.new(ssh, env)
+      # Check if we have a currently open SSH session which has the
+      # same options, and use that if possible
+      session, options = @current_session
+
+      if !session || options != opts
+        env.logger.info("ssh") { "Connecting to SSH: #{env.config.ssh.host} #{opts[:port]}" }
+
+        # The exceptions which are acceptable to retry on during
+        # attempts to connect to SSH
+        exceptions = [Errno::ECONNREFUSED, Net::SSH::Disconnect]
+
+        # Connect to SSH and gather the session
+        session = retryable(:tries => 5, :on => exceptions) do
+          connection = Net::SSH.start(env.config.ssh.host,
+                         env.config.ssh.username,
+                         opts.merge( :keys => [env.config.ssh.private_key_path],
+                                     :keys_only => true,
+                                     :user_known_hosts_file => [],
+                                     :paranoid => false,
+                                     :config => false))
+          SSH::Session.new(connection, env)
         end
+
+        # Save the new session along with the options which created it
+        @current_session = [session, opts]
+      else
+        env.logger.info("ssh") { "Using cached SSH session: #{session}" }
       end
+
+      # Yield our session for executing
+      return yield session if block_given?
     rescue Errno::ECONNREFUSED
       raise Errors::SSHConnectionRefused
     end
@@ -107,6 +128,7 @@ module Vagrant
       # Windows
       ssh_port = port
 
+      require 'timeout'
       Timeout.timeout(env.config.ssh.timeout) do
         execute(:timeout => env.config.ssh.timeout,
                 :port => ssh_port) { |ssh| }
@@ -124,13 +146,16 @@ module Vagrant
     # if needed, or on failure erroring.
     def check_key_permissions(key_path)
       # Windows systems don't have this issue
-      return if Mario::Platform.windows?
+      return if Util::Platform.windows?
+
+      env.logger.info("ssh") { "Checking key permissions: #{key_path}" }
 
       stat = File.stat(key_path)
 
       if stat.owned? && file_perms(key_path) != "600"
-        File.chmod(0600, key_path)
+        env.logger.info("ssh") { "Attempting to correct key permissions to 0600" }
 
+        File.chmod(0600, key_path)
         raise Errors::SSHKeyBadPermissions, :key_path => key_path if file_perms(key_path) != "600"
       end
     rescue Errno::EPERM
@@ -151,23 +176,32 @@ module Vagrant
     # `config.ssh.forwarded_port_key`.
     def port(opts={})
       # Check if port was specified in options hash
-      pnum = opts[:port]
-      return pnum if pnum
+      return opts[:port] if opts[:port]
 
       # Check if a port was specified in the config
       return env.config.ssh.port if env.config.ssh.port
-      
+
       # Check if we have an SSH forwarded port
-      pnum = nil
+      pnum_by_name = nil
+      pnum_by_destination = nil
       env.vm.vm.network_adapters.each do |na|
-        pnum = na.nat_driver.forwarded_ports.detect do |fp|
+        # Look for the port number by name...
+        pnum_by_name = na.nat_driver.forwarded_ports.detect do |fp|
           fp.name == env.config.ssh.forwarded_port_key
         end
 
-        break if pnum
+        # Look for the port number by destination...
+        pnum_by_destination = na.nat_driver.forwarded_ports.detect do |fp|
+          fp.guestport == env.config.ssh.forwarded_port_destination
+        end
+
+        # pnum_by_name is what we're looking for here, so break early
+        # if we have it.
+        break if pnum_by_name
       end
 
-      return pnum.hostport if pnum
+      return pnum_by_name.hostport if pnum_by_name
+      return pnum_by_destination.hostport if pnum_by_destination
 
       # This should NEVER happen.
       raise Errors::SSHPortNotDetected