vagrantup 0.8.10 → 0.9.0

data/lib/vagrant/provisioners/base.rb

@@ -1,52 +1,29 @@
 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.
+    # provisioning a Vagrant system.
+    #
+    # This has been abstracted out so it is easy to provide support for
+    # multiple solutions.
     class Base
       include Vagrant::Util
 
-      # The environment which provisioner is running in. This is a
-      # {Vagrant::Action::Environment}
-      attr_reader :action_env
+      # The environment which provisioner is running in. This is the
+      # action environment, not a Vagrant::Environment.
+      attr_reader :env
 
       # The configuration for this provisioner. This will be an instance of
       # the `Config` class which is part of the provisioner.
       attr_reader :config
 
-      # Registers a provisioner with a given shortcut. This allows that provisioner
-      # to be referenced with the shortcut.
-      #
-      # @param [Symbol] shortcut
-      def self.register(shortcut)
-        registered[shortcut] = self
-      end
-
-      # Returns the provisioner associated with the given shortcut.
-      def self.registered
-        @@registered ||= {}
-      end
-
       def initialize(env, config)
-        @action_env = env
+        @env = env
         @config = config
       end
 
-      # Returns the actual {Vagrant::Environment} which this provisioner
-      # represents.
-      #
-      # @return [Vagrant::Environment]
-      def env
-        action_env.env
-      end
-
-      # Returns the VM which this provisioner is working on.
-      #
-      # @return [Vagrant::VM]
-      def vm
-        env.vm
-      end
+      # This method is expected to return a class that is used for configuration
+      # for the provisioner.
+      def self.config_class; end
 
       # 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}).

data/lib/vagrant/provisioners/chef.rb

@@ -1,3 +1,5 @@
+require 'tempfile'
+
 module Vagrant
   module Provisioners
     # This class is a base class where the common functionality shared between
@@ -17,11 +19,12 @@ module Vagrant
       end
 
       def verify_binary(binary)
-        vm.ssh.execute do |ssh|
-          # Checks for the existence of chef binary and error if it
-          # doesn't exist.
-          ssh.sudo!("which #{binary}", :error_class => ChefError, :_key => :chef_not_detected, :binary => binary)
-        end
+        # Checks for the existence of chef binary and error if it
+        # doesn't exist.
+        env[:vm].channel.sudo("which #{binary}",
+                              :error_class => ChefError,
+                              :error_key => :chef_not_detected,
+                              :binary => binary)
       end
 
       # Returns the path to the Chef binary, taking into account the
@@ -32,10 +35,8 @@ module Vagrant
       end
 
       def chown_provisioning_folder
-        vm.ssh.execute do |ssh|
-          ssh.sudo!("mkdir -p #{config.provisioning_path}")
-          ssh.sudo!("chown #{env.config.ssh.username} #{config.provisioning_path}")
-        end
+        env[:vm].channel.sudo("mkdir -p #{config.provisioning_path}")
+        env[:vm].channel.sudo("chown #{env[:vm].config.ssh.username} #{config.provisioning_path}")
       end
 
       def setup_config(template, filename, template_vars)
@@ -50,17 +51,23 @@ module Vagrant
           :no_proxy => config.no_proxy
         }.merge(template_vars))
 
-        vm.ssh.upload!(StringIO.new(config_file), File.join(config.provisioning_path, filename))
+        # Create a temporary file to store the data so we
+        # can upload it
+        temp = Tempfile.new("vagrant")
+        temp.write(config_file)
+        temp.close
+
+        env[:vm].channel.upload(temp.path, File.join(config.provisioning_path, filename))
       end
 
       def setup_json
-        env.ui.info I18n.t("vagrant.provisioners.chef.json")
+        env[:ui].info I18n.t("vagrant.provisioners.chef.json")
 
         # Set up our configuration that is passed to the attributes by default
-        data = { :config => env.config.to_hash }
+        data = { :config => env[:global_config].to_hash }
 
         # Add our default share directory if it exists
-        default_share = env.config.vm.shared_folders["v-root"]
+        default_share = env[:vm].config.vm.shared_folders["v-root"]
         data[:directory] = default_share[:guestpath] if default_share
 
         # And wrap it under the "vagrant" namespace
@@ -72,7 +79,13 @@ module Vagrant
 
         json = data.to_json
 
-        vm.ssh.upload!(StringIO.new(json), File.join(config.provisioning_path, "dna.json"))
+        # Create a temporary file to store the data so we
+        # can upload it
+        temp = Tempfile.new("vagrant")
+        temp.write(json)
+        temp.close
+
+        env[:vm].channel.upload(temp.path, File.join(config.provisioning_path, "dna.json"))
       end
     end
 
@@ -99,22 +112,13 @@ module Vagrant
         attr_accessor :no_proxy
         attr_accessor :binary_path
         attr_accessor :binary_env
+        attr_accessor :attempts
         attr_writer :run_list
 
         def initialize
-          @provisioning_path = nil
-          @log_level = :info
+          @attempts = 1
           @json = {}
-          @http_proxy = nil
-          @http_proxy_user = nil
-          @http_proxy_pass = nil
-          @https_proxy = nil
-          @https_proxy_user = nil
-          @https_proxy_pass = nil
-          @no_proxy = nil
-          @binary_path = nil
-          @binary_env = nil
-          @run_list = nil
+          @log_level = :info
         end
 
         # This returns the json that is merged with the defaults and the

data/lib/vagrant/provisioners/chef_client.rb

@@ -1,12 +1,12 @@
 require 'pathname'
 
+require 'vagrant/provisioners/chef'
+
 module Vagrant
   module Provisioners
     # This class implements provisioning via chef-client, allowing provisioning
     # with a chef server.
     class ChefClient < Chef
-      register :chef_client
-
       class Config < Chef::Config
         attr_accessor :chef_server_url
         attr_accessor :validation_key_path
@@ -25,11 +25,10 @@ module Vagrant
           @client_key_path = "/etc/chef/client.pem"
           @file_cache_path = "/srv/chef/file_store"
           @file_backup_path = "/srv/chef/cache"
-          @encrypted_data_bag_secret_key_path = nil
           @encrypted_data_bag_secret = "/tmp/encrypted_data_bag_secret"
         end
 
-        def validate(errors)
+        def validate(env, errors)
           super
 
           errors.add(I18n.t("vagrant.config.chef.server_url_empty")) if !chef_server_url || chef_server_url.strip == ""
@@ -38,6 +37,10 @@ module Vagrant
         end
       end
 
+      def self.config_class
+        Config
+      end
+
       def prepare
         raise ChefError, :server_validation_key_required if config.validation_key_path.nil?
         raise ChefError, :server_validation_key_doesnt_exist if !File.file?(validation_key_path)
@@ -56,26 +59,25 @@ module Vagrant
       end
 
       def create_client_key_folder
-        env.ui.info I18n.t("vagrant.provisioners.chef.client_key_folder")
+        env[:ui].info I18n.t("vagrant.provisioners.chef.client_key_folder")
         path = Pathname.new(config.client_key_path)
 
-        vm.ssh.execute do |ssh|
-          ssh.sudo!("mkdir -p #{path.dirname}")
-        end
+        env[:vm].channel.sudo("mkdir -p #{path.dirname}")
       end
 
       def upload_validation_key
-        env.ui.info I18n.t("vagrant.provisioners.chef.upload_validation_key")
-        vm.ssh.upload!(validation_key_path, guest_validation_key_path)
+        env[:ui].info I18n.t("vagrant.provisioners.chef.upload_validation_key")
+        env[:vm].channel.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)
+        env[:ui].info I18n.t("vagrant.provisioners.chef.upload_encrypted_data_bag_secret_key")
+        env[:vm].channel.upload(encrypted_data_bag_secret_key_path,
+                                config.encrypted_data_bag_secret)
       end
 
       def setup_server_config
-        setup_config("chef_server_client", "client.rb", {
+        setup_config("provisioners/chef_client/client", "client.rb", {
           :node_name => config.node_name,
           :chef_server_url => config.chef_server_url,
           :validation_client_name => config.validation_client_name,
@@ -92,24 +94,36 @@ module Vagrant
         command_env = config.binary_env ? "#{config.binary_env} " : ""
         command = "#{command_env}#{chef_binary_path("chef-client")} -c #{config.provisioning_path}/client.rb -j #{config.provisioning_path}/dna.json"
 
-        env.ui.info I18n.t("vagrant.provisioners.chef.running_client")
-        vm.ssh.execute do |ssh|
-          ssh.sudo!(command) do |channel, type, data|
-            if type == :exit_status
-              ssh.check_exit_status(data, command)
-            else
-              env.ui.info("#{data}: #{type}")
-            end
+        config.attempts.times do |attempt|
+          if attempt == 0
+            env[:ui].info I18n.t("vagrant.provisioners.chef.running_client")
+          else
+            env[:ui].info I18n.t("vagrant.provisioners.chef.running_client_again")
           end
+
+          exit_status = env[:vm].channel.sudo(command) do |type, data|
+            # Output the data with the proper color based on the stream.
+            color = type == :stdout ? :green : :red
+
+            # Note: Be sure to chomp the data to avoid the newlines that the
+            # Chef outputs.
+            env[:ui].info(data.chomp, :color => color, :prefix => false)
+          end
+
+          # There is no need to run Chef again if it converges
+          return if exit_status == 0
         end
+
+        # If we reached this point then Chef never converged! Error.
+        raise ChefError, :no_convergence
       end
 
       def validation_key_path
-        File.expand_path(config.validation_key_path, env.root_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)
+        File.expand_path(config.encrypted_data_bag_secret_key_path, env[:root_path])
       end
 
       def guest_validation_key_path

data/lib/vagrant/provisioners/chef_solo.rb

@@ -1,9 +1,11 @@
+require "log4r"
+
+require 'vagrant/provisioners/chef'
+
 module Vagrant
   module Provisioners
     # This class implements provisioning via chef-solo.
     class ChefSolo < Chef
-      register :chef_solo
-
       extend Util::Counter
       include Util::Counter
 
@@ -18,12 +20,10 @@ module Vagrant
           super
 
           @cookbooks_path = ["cookbooks", [:vm, "cookbooks"]]
-          @roles_path = nil
-          @data_bags_path = nil
           @nfs = false
         end
 
-        def validate(errors)
+        def validate(env, errors)
           super
 
           errors.add(I18n.t("vagrant.config.chef.cookbooks_path_empty")) if !cookbooks_path || [cookbooks_path].flatten.empty?
@@ -35,6 +35,15 @@ module Vagrant
       attr_reader :role_folders
       attr_reader :data_bags_folders
 
+      def self.config_class
+        Config
+      end
+
+      def initialize(env, config)
+        super
+        @logger = Log4r::Logger.new("vagrant::provisioners::chef_solo")
+      end
+
       def prepare
         @cookbook_folders = expanded_folders(config.cookbooks_path, "cookbooks")
         @role_folders = expanded_folders(config.roles_path, "roles")
@@ -46,6 +55,19 @@ module Vagrant
       end
 
       def provision!
+        # Verify that the proper shared folders exist.
+        check = []
+        [@cookbook_folders, @role_folders, @data_bags_folders].each do |folders|
+          folders.each do |type, local_path, remote_path|
+            # We only care about checking folders that have a local path, meaning
+            # they were shared from the local machine, rather than assumed to
+            # exist on the VM.
+            check << remote_path if local_path
+          end
+        end
+
+        verify_shared_folders(check)
+
         verify_binary(chef_binary_path("chef-solo"))
         chown_provisioning_folder
         setup_json
@@ -68,7 +90,7 @@ module Vagrant
           # 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
+          local_path = File.expand_path(path, env[:root_path]) if type == :host
           remote_path = nil
           if type == :host
             # Path exists on the host, setup the remote path
@@ -98,7 +120,7 @@ module Vagrant
       def share_folders(prefix, folders)
         folders.each do |type, local_path, remote_path|
           if type == :host
-            env.config.vm.share_folder("v-#{prefix}-#{self.class.get_and_update_counter(:shared_folder)}",
+            env[:vm].config.vm.share_folder("v-#{prefix}-#{self.class.get_and_update_counter(:shared_folder)}",
                                        remote_path, local_path, :nfs => config.nfs)
           end
         end
@@ -109,7 +131,7 @@ module Vagrant
         roles_path = guest_paths(@role_folders).first
         data_bags_path = guest_paths(@data_bags_folders).first
 
-        setup_config("chef_solo_solo", "solo.rb", {
+        setup_config("provisioners/chef_solo/solo", "solo.rb", {
           :node_name => config.node_name,
           :provisioning_path => config.provisioning_path,
           :cookbooks_path => cookbooks_path,
@@ -123,18 +145,41 @@ module Vagrant
         command_env = config.binary_env ? "#{config.binary_env} " : ""
         command = "#{command_env}#{chef_binary_path("chef-solo")} -c #{config.provisioning_path}/solo.rb -j #{config.provisioning_path}/dna.json"
 
-        env.ui.info I18n.t("vagrant.provisioners.chef.running_solo")
-        vm.ssh.execute do |ssh|
-          ssh.sudo!(command) do |channel, type, data|
-            if type == :exit_status
-              ssh.check_exit_status(data, command)
-            else
-              env.ui.info("#{data}: #{type}")
-            end
+        config.attempts.times do |attempt|
+          if attempt == 0
+            env[:ui].info I18n.t("vagrant.provisioners.chef.running_solo")
+          else
+            env[:ui].info I18n.t("vagrant.provisioners.chef.running_solo_again")
+          end
+
+          exit_status = env[:vm].channel.sudo(command, :error_check => false) do |type, data|
+            # Output the data with the proper color based on the stream.
+            color = type == :stdout ? :green : :red
+
+            # Note: Be sure to chomp the data to avoid the newlines that the
+            # Chef outputs.
+            env[:ui].info(data.chomp, :color => color, :prefix => false)
           end
+
+          # There is no need to run Chef again if it converges
+          return if exit_status == 0
         end
+
+        # If we reached this point then Chef never converged! Error.
+        raise ChefError, :no_convergence
       end
 
+      def verify_shared_folders(folders)
+        folders.each do |folder|
+          @logger.debug("Checking for shared folder: #{folder}")
+          if !env[:vm].channel.test("test -d #{folder}")
+            raise ChefError, :missing_shared_folders
+          end
+        end
+      end
+
+      protected
+
       # Extracts only the remote paths from a list of folders
       def guest_paths(folders)
         folders.map { |parts| parts[2] }

data/lib/vagrant/provisioners/puppet.rb

@@ -1,3 +1,5 @@
+require "log4r"
+
 module Vagrant
   module Provisioners
     class PuppetError < Vagrant::Errors::VagrantError
@@ -5,8 +7,6 @@ module Vagrant
     end
 
     class Puppet < Base
-      register :puppet
-
       class Config < Vagrant::Config::Base
         attr_accessor :manifest_file
         attr_accessor :manifests_path
@@ -15,28 +15,21 @@ module Vagrant
         attr_accessor :options
 
         def initialize
-          @manifest_file = nil
+          @manifest_file = "default.pp"
           @manifests_path = "manifests"
-          @module_path = nil
           @pp_path = "/tmp/vagrant-puppet"
           @options = []
         end
 
         # Returns the manifests path expanded relative to the root path of the
         # environment.
-        def expanded_manifests_path
-          Pathname.new(manifests_path).expand_path(env.root_path)
-        end
-
-        # Returns the manifest file if set otherwise returns the box name pp file
-        # which may or may not exist.
-        def computed_manifest_file
-          manifest_file || "#{top.vm.box}.pp"
+        def expanded_manifests_path(root_path)
+          Pathname.new(manifests_path).expand_path(root_path)
         end
 
         # Returns the module paths as an array of paths expanded relative to the
         # root path.
-        def expanded_module_paths
+        def expanded_module_paths(root_path)
           return [] if !module_path
 
           # Get all the paths and expand them relative to the root path, returning
@@ -44,24 +37,29 @@ module Vagrant
           paths = module_path
           paths = [paths] if !paths.is_a?(Array)
           paths.map do |path|
-            Pathname.new(path).expand_path(env.root_path)
+            Pathname.new(path).expand_path(root_path)
           end
         end
 
-        def validate(errors)
-          super
+        def validate(env, errors)
+          # Calculate the manifests and module paths based on env
+          this_expanded_manifests_path = expanded_manifests_path(env.root_path)
+          this_expanded_module_paths = expanded_module_paths(env.root_path)
 
           # Manifests path/file validation
-          if !expanded_manifests_path.directory?
-            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing", :path => expanded_manifests_path))
+          if !this_expanded_manifests_path.directory?
+            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing",
+                              :path => this_expanded_manifests_path))
           else
-            if !expanded_manifests_path.join(computed_manifest_file).file?
-              errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing", :manifest => computed_manifest_file))
+            expanded_manifest_file = this_expanded_manifests_path.join(manifest_file)
+            if !expanded_manifest_file.file?
+              errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing",
+                                :manifest => expanded_manifest_file.to_s))
             end
           end
 
           # Module paths validation
-          expanded_module_paths.each do |path|
+          this_expanded_module_paths.each do |path|
             if !path.directory?
               errors.add(I18n.t("vagrant.provisioners.puppet.module_path_missing", :path => path))
             end
@@ -69,19 +67,43 @@ module Vagrant
         end
       end
 
+      def self.config_class
+        Config
+      end
+
+      def initialize(env, config)
+        super
+
+        @logger = Log4r::Logger.new("vagrant::provisioners::puppet")
+      end
+
       def prepare
+        # Calculate the paths we're going to use based on the environment
+        @expanded_manifests_path = config.expanded_manifests_path(env[:root_path])
+        @expanded_module_paths   = config.expanded_module_paths(env[:root_path])
+        @manifest_file           = File.join(manifests_guest_path, config.manifest_file)
+
         set_module_paths
         share_manifests
         share_module_paths
       end
 
       def provision!
+        # Check that the shared folders are properly shared
+        check = [manifests_guest_path]
+        @module_paths.each do |host_path, guest_path|
+          check << guest_path
+        end
+
+        verify_shared_folders(check)
+
+        # Verify Puppet is installed and run it
         verify_binary("puppet")
         run_puppet_client
       end
 
       def share_manifests
-        env.config.vm.share_folder("manifests", manifests_guest_path, config.expanded_manifests_path)
+        env[:vm].config.vm.share_folder("manifests", manifests_guest_path, @expanded_manifests_path)
       end
 
       def share_module_paths
@@ -89,14 +111,14 @@ module Vagrant
         @module_paths.each do |from, to|
           # Sorry for the cryptic key here, but VirtualBox has a strange limit on
           # maximum size for it and its something small (around 10)
-          env.config.vm.share_folder("v-pp-m#{count}", to, from)
+          env[:vm].config.vm.share_folder("v-pp-m#{count}", to, from)
           count += 1
         end
       end
 
       def set_module_paths
         @module_paths = {}
-        config.expanded_module_paths.each_with_index do |path, i|
+        @expanded_module_paths.each_with_index do |path, i|
           @module_paths[path] = File.join(config.pp_path, "modules-#{i}")
         end
       end
@@ -106,32 +128,42 @@ module Vagrant
       end
 
       def verify_binary(binary)
-        vm.ssh.execute do |ssh|
-          ssh.sudo!("which #{binary}", :error_class => PuppetError, :_key => :puppet_not_detected, :binary => binary)
-        end
+        env[:vm].channel.sudo("which #{binary}",
+                              :error_class => PuppetError,
+                              :error_key => :puppet_not_detected,
+                              :binary => binary)
       end
 
       def run_puppet_client
         options = [config.options].flatten
         options << "--modulepath '#{@module_paths.values.join(':')}'" if !@module_paths.empty?
-        options << config.computed_manifest_file
+        options << @manifest_file
         options = options.join(" ")
 
-        commands = ["cd #{manifests_guest_path}",
-                    "puppet apply #{options}"]
+        command = "cd #{manifests_guest_path} && puppet apply #{options}"
 
-        env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet", :manifest => config.computed_manifest_file)
+        env[:ui].info I18n.t("vagrant.provisioners.puppet.running_puppet",
+                             :manifest => @manifest_file)
 
-        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
+        env[:vm].channel.sudo(command) do |type, data|
+          # Output the data with the proper color based on the stream.
+          color = type == :stdout ? :green : :red
+
+          # Note: Be sure to chomp the data to avoid the newlines that the
+          # Chef outputs.
+          env[:ui].info(data.chomp, :color => color, :prefix => false)
+        end
+      end
+
+      def verify_shared_folders(folders)
+        folders.each do |folder|
+          @logger.debug("Checking for shared folder: #{folder}")
+          if !env[:vm].channel.test("test -d #{folder}")
+            raise PuppetError, :missing_shared_folders
           end
         end
       end
     end
   end
 end
+