vagrant 1.0.7 → 1.5.0

data/lib/vagrant/provisioners/chef_client.rb

@@ -1,132 +0,0 @@
-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
-      class Config < Chef::Config
-        attr_accessor :chef_server_url
-        attr_accessor :validation_key_path
-        attr_accessor :validation_client_name
-        attr_accessor :client_key_path
-        attr_accessor :file_cache_path
-        attr_accessor :file_backup_path
-        attr_accessor :environment
-        attr_accessor :encrypted_data_bag_secret_key_path
-        attr_accessor :encrypted_data_bag_secret
-
-        # Provide defaults in such a way that they won't override the instance
-        # variable. This is so merging continues to work properly.
-        def validation_client_name; @validation_client_name || "chef-validator"; end
-        def client_key_path; @client_key_path || "/etc/chef/client.pem"; end
-        def file_cache_path; @file_cache_path || "/srv/chef/file_store"; end
-        def file_backup_path; @file_backup_path || "/srv/chef/cache"; end
-        def encrypted_data_bag_secret; @encrypted_data_bag_secret || "/tmp/encrypted_data_bag_secret"; end
-
-        def validate(env, errors)
-          super
-
-          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 @run_list && @run_list.empty?
-        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)
-        raise ChefError, :server_url_required if config.chef_server_url.nil?
-      end
-
-      def provision!
-        verify_binary(chef_binary_path("chef-client"))
-        chown_provisioning_folder
-        create_client_key_folder
-        upload_validation_key
-        upload_encrypted_data_bag_secret if config.encrypted_data_bag_secret_key_path
-        setup_json
-        setup_server_config
-        run_chef_client
-      end
-
-      def create_client_key_folder
-        env[:ui].info I18n.t("vagrant.provisioners.chef.client_key_folder")
-        path = Pathname.new(config.client_key_path)
-
-        env[:vm].channel.sudo("mkdir -p #{path.dirname}")
-      end
-
-      def upload_validation_key
-        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")
-        env[:vm].channel.upload(encrypted_data_bag_secret_key_path,
-                                config.encrypted_data_bag_secret)
-      end
-
-      def setup_server_config
-        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,
-          :validation_key => guest_validation_key_path,
-          :client_key => config.client_key_path,
-          :file_cache_path => config.file_cache_path,
-          :file_backup_path => config.file_backup_path,
-          :environment => config.environment,
-          :encrypted_data_bag_secret => config.encrypted_data_bag_secret
-        })
-      end
-
-      def run_chef_client
-        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"
-
-        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])
-      end
-
-      def encrypted_data_bag_secret_key_path
-        File.expand_path(config.encrypted_data_bag_secret_key_path, env[:root_path])
-      end
-
-      def guest_validation_key_path
-        File.join(config.provisioning_path, "validation.pem")
-      end
-    end
-  end
-end

data/lib/vagrant/provisioners/chef_solo.rb

@@ -1,234 +0,0 @@
-require "log4r"
-
-require 'vagrant/provisioners/chef'
-
-module Vagrant
-  module Provisioners
-    # This class implements provisioning via chef-solo.
-    class ChefSolo < Chef
-      extend Util::Counter
-      include Util::Counter
-
-      class Config < Chef::Config
-        attr_accessor :cookbooks_path
-        attr_accessor :roles_path
-        attr_accessor :data_bags_path
-        attr_accessor :recipe_url
-        attr_accessor :nfs
-        attr_accessor :encrypted_data_bag_secret_key_path
-        attr_accessor :encrypted_data_bag_secret
-
-        def encrypted_data_bag_secret; @encrypted_data_bag_secret || "/tmp/encrypted_data_bag_secret"; end
-
-        def initialize
-          super
-
-          @__default = ["cookbooks", [:vm, "cookbooks"]]
-        end
-
-        # Provide defaults in such a way that they won't override the instance
-        # variable. This is so merging continues to work properly.
-        def cookbooks_path
-          @cookbooks_path || _default_cookbook_path
-        end
-
-        # This stores a reference to the default cookbook path which is used
-        # later. Do not use this publicly. I apologize for not making it
-        # "protected" but it has to be called by Vagrant internals later.
-        def _default_cookbook_path
-          @__default
-        end
-
-        def nfs
-          @nfs || false
-        end
-
-        def validate(env, errors)
-          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 !run_list || run_list.empty?
-        end
-      end
-
-      attr_reader :cookbook_folders
-      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")
-        @data_bags_folders = expanded_folders(config.data_bags_path, "data_bags")
-
-        share_folders("csc", @cookbook_folders)
-        share_folders("csr", @role_folders)
-        share_folders("csdb", @data_bags_folders)
-      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
-        upload_encrypted_data_bag_secret if config.encrypted_data_bag_secret_key_path
-        setup_json
-        setup_solo_config
-        run_chef_solo
-      end
-
-      # Converts paths to a list of properly expanded paths with types.
-      def expanded_folders(paths, appended_folder=nil)
-        return [] if paths.nil?
-
-        # 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)
-
-        results = []
-        paths.each 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
-          remote_path = nil
-          if type == :host
-            # Get the expanded path that the host path points to
-            local_path = File.expand_path(path, env[:root_path])
-
-            # Super hacky but if we're expanded the default cookbook paths,
-            # and one of the host paths doesn't exist, then just ignore it,
-            # because that is fine.
-            if paths.equal?(config._default_cookbook_path) && !File.directory?(local_path)
-              @logger.info("'cookbooks' folder doesn't exist on defaults. Ignoring.")
-              next
-            end
-
-            # Path exists on the host, setup the remote path
-            remote_path = "#{config.provisioning_path}/chef-solo-#{get_and_update_counter(:cookbooks_path)}"
-          else
-            # Path already exists on the virtual machine. Expand it
-            # relative to where we're provisioning.
-            remote_path = File.expand_path(path, config.provisioning_path)
-
-            # Remove drive letter if running on a windows host. This is a bit
-            # of a hack but is the most portable way I can think of at the moment
-            # to achieve this. Otherwise, Vagrant attempts to share at some crazy
-            # path like /home/vagrant/c:/foo/bar
-            remote_path = remote_path.gsub(/^[a-zA-Z]:/, "")
-          end
-
-          # If we have specified a folder name to append then append it
-          remote_path += "/#{appended_folder}" if appended_folder
-
-          # Append the result
-          results << [type, local_path, remote_path]
-        end
-
-        results
-      end
-
-      # 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)
-        folders.each do |type, local_path, remote_path|
-          if type == :host
-            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
-      end
-
-      def upload_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_solo_config
-        cookbooks_path = guest_paths(@cookbook_folders)
-        roles_path = guest_paths(@role_folders).first
-        data_bags_path = guest_paths(@data_bags_folders).first
-
-        setup_config("provisioners/chef_solo/solo", "solo.rb", {
-          :node_name => config.node_name,
-          :provisioning_path => config.provisioning_path,
-          :cookbooks_path => cookbooks_path,
-          :recipe_url => config.recipe_url,
-          :roles_path => roles_path,
-          :data_bags_path => data_bags_path,
-          :encrypted_data_bag_secret => config.encrypted_data_bag_secret,
-        })
-      end
-
-      def run_chef_solo
-        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"
-
-        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
-
-      def encrypted_data_bag_secret_key_path
-        File.expand_path(config.encrypted_data_bag_secret_key_path, env[:root_path])
-      end
-
-      protected
-
-      # Extracts only the remote paths from a list of folders
-      def guest_paths(folders)
-        folders.map { |parts| parts[2] }
-      end
-    end
-  end
-end

data/lib/vagrant/provisioners/puppet.rb

@@ -1,176 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Provisioners
-    class PuppetError < Vagrant::Errors::VagrantError
-      error_namespace("vagrant.provisioners.puppet")
-    end
-
-    class Puppet < Base
-      class Config < Vagrant::Config::Base
-        attr_accessor :manifest_file
-        attr_accessor :manifests_path
-        attr_accessor :module_path
-        attr_accessor :pp_path
-        attr_accessor :options
-        attr_accessor :facter
-
-        def manifest_file; @manifest_file || "default.pp"; end
-        def manifests_path; @manifests_path || "manifests"; end
-        def pp_path; @pp_path || "/tmp/vagrant-puppet"; end
-        def options; @options ||= []; end
-        def facter; @facter ||= {}; end
-
-        # Returns the manifests path expanded relative to the root path of the
-        # environment.
-        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(root_path)
-          return [] if !module_path
-
-          # Get all the paths and expand them relative to the root path, returning
-          # the array of expanded paths
-          paths = module_path
-          paths = [paths] if !paths.is_a?(Array)
-          paths.map do |path|
-            Pathname.new(path).expand_path(root_path)
-          end
-        end
-
-        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 !this_expanded_manifests_path.directory?
-            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing",
-                              :path => this_expanded_manifests_path))
-          else
-            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
-          this_expanded_module_paths.each do |path|
-            if !path.directory?
-              errors.add(I18n.t("vagrant.provisioners.puppet.module_path_missing", :path => path))
-            end
-          end
-        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[:vm].config.vm.share_folder("manifests", manifests_guest_path, @expanded_manifests_path)
-      end
-
-      def share_module_paths
-        count = 0
-        @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[:vm].config.vm.share_folder("v-pp-m#{count}", to, from)
-          count += 1
-        end
-      end
-
-      def set_module_paths
-        @module_paths = []
-        @expanded_module_paths.each_with_index do |path, i|
-          @module_paths << [path, File.join(config.pp_path, "modules-#{i}")]
-        end
-      end
-
-      def manifests_guest_path
-        File.join(config.pp_path, "manifests")
-      end
-
-      def verify_binary(binary)
-        env[:vm].channel.sudo("which #{binary}",
-                              :error_class => PuppetError,
-                              :error_key => :not_detected,
-                              :binary => binary)
-      end
-
-      def run_puppet_client
-        options = [config.options].flatten
-        module_paths = @module_paths.map { |_, to| to }
-        options << "--modulepath '#{module_paths.join(':')}'" if !@module_paths.empty?
-        options << @manifest_file
-        options = options.join(" ")
-
-        # Build up the custom facts if we have any
-        facter = ""
-        if !config.facter.empty?
-          facts = []
-          config.facter.each do |key, value|
-            facts << "FACTER_#{key}='#{value}'"
-          end
-
-          facter = "#{facts.join(" ")} "
-        end
-
-        command = "cd #{manifests_guest_path} && #{facter}puppet apply #{options} --detailed-exitcodes || [ $? -eq 2 ]"
-
-        env[:ui].info I18n.t("vagrant.provisioners.puppet.running_puppet",
-                             :manifest => @manifest_file)
-
-        env[:vm].channel.sudo(command) do |type, data|
-          env[:ui].info(data.chomp, :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
-