boxcar 0.10005.1

data/lib/vagrant/provisioners/chef_client.rb

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,234 @@
+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

@@ -0,0 +1,175 @@
+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
+        options << "--modulepath '#{@module_paths.values.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}"
+
+        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
+