tnargav 1.2.2

data/plugins/provisioners/ansible/config.rb

@@ -0,0 +1,72 @@
+module VagrantPlugins
+  module Ansible
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :playbook
+      attr_accessor :extra_vars
+      attr_accessor :inventory_file
+      attr_accessor :ask_sudo_pass
+      attr_accessor :limit
+      attr_accessor :sudo
+      attr_accessor :sudo_user
+      attr_accessor :verbose
+
+      def initialize
+        @playbook       = UNSET_VALUE
+        @extra_vars     = UNSET_VALUE
+        @inventory_file = UNSET_VALUE
+        @ask_sudo_pass  = UNSET_VALUE
+        @limit          = UNSET_VALUE
+        @sudo           = UNSET_VALUE
+        @sudo_user      = UNSET_VALUE
+        @verbose        = UNSET_VALUE
+      end
+
+      def finalize!
+        @playbook       = nil if @playbook == UNSET_VALUE
+        @extra_vars     = nil if @extra_vars == UNSET_VALUE
+        @inventory_file = nil if @inventory_file == UNSET_VALUE
+        @ask_sudo_pass  = nil if @ask_sudo_pass == UNSET_VALUE
+        @limit          = nil if @limit == UNSET_VALUE
+        @sudo           = nil if @sudo == UNSET_VALUE
+        @sudo_user      = nil if @sudo_user == UNSET_VALUE
+        @verbose        = nil if @verbose == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        # Validate that a playbook path was provided
+        if !playbook
+          errors << I18n.t("vagrant.provisioners.ansible.no_playbook")
+        end
+
+        # Validate the existence of said playbook on the host
+        if playbook
+          expanded_path = Pathname.new(playbook).expand_path(machine.env.root_path)
+          if !expanded_path.file?
+            errors << I18n.t("vagrant.provisioners.ansible.playbook_path_invalid",
+                              :path => expanded_path)
+          end
+        end
+
+        # Validate that extra_vars is a hash, if set
+        if extra_vars
+          if !extra_vars.kind_of?(Hash)
+            errors << I18n.t("vagrant.provisioners.ansible.extra_vars_not_hash")
+          end
+        end
+
+        # Validate the existence of the inventory_file, if specified
+        if inventory_file
+          expanded_path = Pathname.new(inventory_file).expand_path(machine.env.root_path)
+          if !expanded_path.file?
+            errors << I18n.t("vagrant.provisioners.ansible.inventory_file_path_invalid",
+                              :path => expanded_path)
+          end
+        end
+
+        { "ansible provisioner" => errors }
+      end
+    end
+  end
+end

data/plugins/provisioners/ansible/plugin.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Ansible
+    class Plugin < Vagrant.plugin("2")
+      name "ansible"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      Ansible playbooks.
+      DESC
+
+      config(:ansible, :provisioner) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+
+      provisioner(:ansible) do
+        require File.expand_path("../provisioner", __FILE__)
+        Provisioner
+      end
+    end
+  end
+end

data/plugins/provisioners/ansible/provisioner.rb

@@ -0,0 +1,45 @@
+module VagrantPlugins
+  module Ansible
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      def provision
+        ssh = @machine.ssh_info
+
+        options = %W[--private-key=#{ssh[:private_key_path]} --user=#{ssh[:username]}]
+        options << "--extra-vars=" + config.extra_vars.map{|k,v| "#{k}=#{v}"}.join(' ') if config.extra_vars
+        options << "--inventory-file=#{config.inventory_file}" if config.inventory_file
+        options << "--ask-sudo-pass" if config.ask_sudo_pass
+
+        if config.limit
+          if not config.limit.kind_of?(Array)
+            config.limit = [config.limit]
+          end
+          config.limit = config.limit.join(",")
+          options << "--limit=#{config.limit}"
+        end
+
+        options << "--sudo" if config.sudo
+        options << "--sudo-user=#{config.sudo_user}" if config.sudo_user
+        options << "--verbose" if config.verbose
+
+        # Assemble the full ansible-playbook command
+        command = (%w(ansible-playbook) << options << config.playbook).flatten
+
+        # Write stdout and stderr data, since it's the regular Ansible output
+        command << {
+          :env => { "ANSIBLE_FORCE_COLOR" => "true" },
+          :notify => [:stdout, :stderr]
+        }
+
+        begin
+          Vagrant::Util::Subprocess.execute(*command) do |type, data|
+            if type == :stdout || type == :stderr
+              @machine.env.ui.info(data.chomp, :prefix => false)
+            end
+          end
+        rescue Vagrant::Util::Subprocess::LaunchError
+          raise Vagrant::Errors::AnsiblePlaybookAppNotFound
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/cfengine/cap/debian/cfengine_install.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module CFEngine
+    module Cap
+      module Debian
+        module CFEngineInstall
+          def self.cfengine_install(machine, config)
+            machine.communicate.tap do |comm|
+              comm.sudo("mkdir -p #{File.dirname(config.deb_repo_file)} && /bin/echo #{config.deb_repo_line} > #{config.deb_repo_file}")
+              comm.sudo("GPGFILE=`tempfile`; wget -O $GPGFILE #{config.repo_gpg_key_url} && apt-key add $GPGFILE; rm -f $GPGFILE")
+
+              comm.sudo("apt-get update")
+              comm.sudo("apt-get install -y cfengine-community")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/cfengine/cap/linux/cfengine_installed.rb

@@ -0,0 +1,14 @@
+module VagrantPlugins
+  module CFEngine
+    module Cap
+      module Linux
+        module CFEngineInstalled
+          def self.cfengine_installed(machine)
+            machine.communicate.test(
+              "test -d /var/cfengine && test -x /var/cfengine/bin/cf-agent", sudo: true)
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/cfengine/cap/linux/cfengine_needs_bootstrap.rb

@@ -0,0 +1,34 @@
+require "log4r"
+
+module VagrantPlugins
+  module CFEngine
+    module Cap
+      module Linux
+        module CFEngineNeedsBootstrap
+          def self.cfengine_needs_bootstrap(machine, config)
+            logger = Log4r::Logger.new("vagrant::plugins::cfengine::cap_linux_cfengine_bootstrap")
+
+            machine.communicate.tap do |comm|
+              # We hardcode fixing the permissions on /var/cfengine/ppkeys/, if it exists,
+              # because otherwise CFEngine will fail to bootstrap.
+              if comm.test("test -d /var/cfengine/ppkeys", :sudo => true)
+                logger.debug("Fixing permissions on /var/cfengine/ppkeys")
+                comm.sudo("chmod -R 600 /var/cfengine/ppkeys")
+              end
+
+              logger.debug("Checking if CFEngine is bootstrapped...")
+              bootstrapped = comm.test("test -f /var/cfengine/policy_server.dat", :sudo => true)
+              if bootstrapped && !config.force_bootstrap
+                logger.info("CFEngine already bootstrapped, no need to do it again")
+                return false
+              end
+
+              logger.info("CFEngine needs bootstrap.")
+              return true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/cfengine/cap/redhat/cfengine_install.rb

@@ -0,0 +1,24 @@
+require "log4r"
+
+module VagrantPlugins
+  module CFEngine
+    module Cap
+      module RedHat
+        module CFEngineInstall
+          def self.cfengine_install(machine, config)
+            logger = Log4r::Logger.new("vagrant::plugins::cfengine::cap_redhat_cfengine_install")
+
+            machine.communicate.tap do |comm|
+              logger.info("Adding the CFEngine repository to #{config.yum_repo_file}")
+              comm.sudo("mkdir -p #{File.dirname(config.yum_repo_file)} && (echo '[cfengine-repository]'; echo 'name=CFEngine Community Yum Repository'; echo 'baseurl=#{config.yum_repo_url}'; echo 'enabled=1'; echo 'gpgcheck=1') > #{config.yum_repo_file}")
+              logger.info("Installing CFEngine Community Yum Repository GPG KEY from #{config.repo_gpg_key_url}")
+              comm.sudo("GPGFILE=$(mktemp) && wget -O $GPGFILE #{config.repo_gpg_key_url} && rpm --import $GPGFILE; rm -f $GPGFILE")
+
+              comm.sudo("yum -y install cfengine-community")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/cfengine/config.rb

@@ -0,0 +1,120 @@
+require "pathname"
+
+require "vagrant"
+
+module VagrantPlugins
+  module CFEngine
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :am_policy_hub
+      attr_accessor :extra_agent_args
+      attr_accessor :classes
+      attr_accessor :deb_repo_file
+      attr_accessor :deb_repo_line
+      attr_accessor :files_path
+      attr_accessor :force_bootstrap
+      attr_accessor :install
+      attr_accessor :mode
+      attr_accessor :policy_server_address
+      attr_accessor :repo_gpg_key_url
+      attr_accessor :run_file
+      attr_accessor :upload_path
+      attr_accessor :yum_repo_file
+      attr_accessor :yum_repo_url
+
+      def initialize
+        @am_policy_hub    = UNSET_VALUE
+        @classes          = UNSET_VALUE
+        @deb_repo_file    = UNSET_VALUE
+        @deb_repo_line    = UNSET_VALUE
+        @extra_agent_args = UNSET_VALUE
+        @files_path       = UNSET_VALUE
+        @force_bootstrap  = UNSET_VALUE
+        @install          = UNSET_VALUE
+        @mode             = UNSET_VALUE
+        @policy_server_address = UNSET_VALUE
+        @repo_gpg_key_url = UNSET_VALUE
+        @run_file         = UNSET_VALUE
+        @upload_path      = UNSET_VALUE
+        @yum_repo_file    = UNSET_VALUE
+        @yum_repo_url     = UNSET_VALUE
+      end
+
+      def finalize!
+        @am_policy_hub = false if @am_policy_hub == UNSET_VALUE
+
+        @classes = nil if @classes == UNSET_VALUE
+
+        if @deb_repo_file == UNSET_VALUE
+          @deb_repo_file = "/etc/apt/sources.list.d/cfengine-community.list"
+        end
+
+        if @deb_repo_line == UNSET_VALUE
+          @deb_repo_line = "deb http://cfengine.com/pub/apt $(lsb_release -cs) main"
+        end
+
+        @extra_agent_args = nil if @extra_agent_args == UNSET_VALUE
+
+        @files_path = nil if @files_path == UNSET_VALUE
+
+        @force_bootstrap = false if @force_bootstrap == UNSET_VALUE
+
+        @install = true if @install == UNSET_VALUE
+        @install = @install.to_sym if @install.respond_to?(:to_sym)
+
+        @mode = :bootstrap if @mode == UNSET_VALUE
+        @mode = @mode.to_sym
+
+        @run_file = nil if @run_file == UNSET_VALUE
+
+        @policy_server_address = nil if @policy_server_address == UNSET_VALUE
+
+        if @repo_gpg_key_url == UNSET_VALUE
+          @repo_gpg_key_url = "http://cfengine.com/pub/gpg.key"
+        end
+
+        @upload_path = "/tmp/vagrant-cfengine-file" if @upload_path == UNSET_VALUE
+
+        if @yum_repo_file == UNSET_VALUE
+          @yum_repo_file = "/etc/yum.repos.d/cfengine-community.repo"
+        end
+
+        if @yum_repo_url == UNSET_VALUE
+          @yum_repo_url = "http://cfengine.com/pub/yum/"
+        end
+      end
+
+      def validate(machine)
+        errors = []
+
+        valid_modes = [:bootstrap, :single_run]
+        errors << I18n.t("vagrant.cfengine_config.invalid_mode") if !valid_modes.include?(@mode)
+
+        if @mode == :bootstrap
+          if !@policy_server_address && !@am_policy_hub
+            errors << I18n.t("vagrant.cfengine_config.policy_server_address")
+          end
+        end
+
+        if @classes && !@classes.is_a?(Array)
+          errors << I18n.t("vagrant.cfengine_config.classes_array")
+        end
+
+        if @files_path
+          expanded = Pathname.new(@files_path).expand_path(machine.env.root_path)
+          if !expanded.directory?
+            errors << I18n.t("vagrant.cfengine_config.files_path_not_directory")
+          end
+        end
+
+        if @run_file
+          expanded = Pathname.new(@run_file).expand_path(machine.env.root_path)
+          if !expanded.file?
+            errors << I18n.t("vagrant.cfengine_config.run_file_not_found")
+          end
+        end
+
+        { "CFEngine" => errors }
+      end
+    end
+  end
+end

data/plugins/provisioners/cfengine/plugin.rb

@@ -0,0 +1,42 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CFEngine
+    class Plugin < Vagrant.plugin("2")
+      name "CFEngine Provisioner"
+      description <<-DESC
+      Provisions machines with CFEngine.
+      DESC
+
+      config(:cfengine, :provisioner) do
+        require_relative "config"
+        Config
+      end
+
+      guest_capability("debian", "cfengine_install") do
+        require_relative "cap/debian/cfengine_install"
+        Cap::Debian::CFEngineInstall
+      end
+
+      guest_capability("linux", "cfengine_needs_bootstrap") do
+        require_relative "cap/linux/cfengine_needs_bootstrap"
+        Cap::Linux::CFEngineNeedsBootstrap
+      end
+
+      guest_capability("linux", "cfengine_installed") do
+        require_relative "cap/linux/cfengine_installed"
+        Cap::Linux::CFEngineInstalled
+      end
+
+      guest_capability("redhat", "cfengine_install") do
+        require_relative "cap/redhat/cfengine_install"
+        Cap::RedHat::CFEngineInstall
+      end
+
+      provisioner(:cfengine) do
+        require_relative "provisioner"
+        Provisioner
+      end
+    end
+  end
+end

data/plugins/provisioners/cfengine/provisioner.rb

@@ -0,0 +1,136 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module CFEngine
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      def provision
+        @logger = Log4r::Logger.new("vagrant::plugins::cfengine")
+
+        @logger.info("Checking for CFEngine installation...")
+        handle_cfengine_installation
+
+        if @config.files_path
+          @machine.ui.info(I18n.t("vagrant.cfengine_installing_files_path"))
+          install_files(Pathname.new(@config.files_path).expand_path(@machine.env.root_path))
+        end
+
+        handle_cfengine_bootstrap if @config.mode == :bootstrap
+
+        if @config.mode == :single_run
+          # Just let people know
+          @machine.ui.info(I18n.t("vagrant.cfengine_single_run"))
+        end
+
+        if @config.run_file
+          @machine.ui.info(I18n.t("vagrant.cfengine_single_run_execute"))
+          path = Pathname.new(@config.run_file).expand_path(@machine.env.root_path)
+          machine.communicate.upload(path.to_s, @config.upload_path)
+          cfagent("-KI -f #{@config.upload_path}#{cfagent_classes_args}#{cfagent_extra_args}")
+        end
+      end
+
+      protected
+
+      # This runs cf-agent with the given arguments.
+      def cfagent(args, options=nil)
+        options ||= {}
+        command = "/var/cfengine/bin/cf-agent #{args}"
+
+        @machine.communicate.sudo(command, error_check: options[:error_check]) do |type, data|
+          if [:stderr, :stdout].include?(type)
+            # 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.
+            @machine.ui.info(data.chomp, :color => color, :prefix => false)
+          end
+        end
+      end
+
+      # Returns the arguments for the classes configuration if they are
+      # set.
+      #
+      # @return [String]
+      def cfagent_classes_args
+        return "" if !@config.classes
+
+        args = @config.classes.map { |c| "-D#{c}" }.join(" ")
+        return " #{args}"
+      end
+
+      # Extra arguments for calles to cf-agent.
+      #
+      # @return [String]
+      def cfagent_extra_args
+        return "" if !@config.extra_agent_args
+        return " #{@config.extra_agent_args}"
+      end
+
+      # This handles checking if the CFEngine installation needs to
+      # be bootstrapped, and bootstraps if it does.
+      def handle_cfengine_bootstrap
+        @logger.info("Bootstrapping CFEngine...")
+        if !@machine.guest.capability(:cfengine_needs_bootstrap, @config)
+          @machine.ui.info(I18n.t("vagrant.cfengine_no_bootstrap"))
+          return
+        end
+
+        # Needs bootstrap, let's determine the parameters
+        policy_server_address = @config.policy_server_address
+        if !policy_server_address
+          policy_server_address = @machine.guest.capability(:read_ip_address)
+          raise Vagrant::Errors::CFEngineCantAutodetectIP if !policy_server_address
+          @machine.ui.info(I18n.t("vagrant.cfengine_detected_ip", address: policy_server_address))
+        end
+
+        @machine.ui.info(I18n.t("vagrant.cfengine_bootstrapping",
+                                policy_server: policy_server_address))
+        result = cfagent("--bootstrap --policy-server #{policy_server_address}", error_check: false)
+        raise Vagrant::Errors::CFEngineBootstrapFailed if result != 0
+
+        # Policy hubs need to do additional things before they're ready
+        # to accept agents. Force that run now...
+        if @config.am_policy_hub
+          @machine.ui.info(I18n.t("vagrant.cfengine_bootstrapping_policy_hub"))
+          cfagent("-KI -f /var/cfengine/masterfiles/failsafe.cf#{cfagent_classes_args}")
+          cfagent("-KI #{cfagent_classes_args}#{cfagent_extra_args}")
+        end
+      end
+
+      # This handles verifying the CFEngine installation, installing it
+      # if it was requested, and so on. This method will raise exceptions
+      # if things are wrong.
+      def handle_cfengine_installation
+        if !@machine.guest.capability?(:cfengine_installed)
+          @machine.ui.warn(I18n.t("vagrant.cfengine_cant_detect"))
+          return
+        end
+
+        installed = @machine.guest.capability(:cfengine_installed)
+        if !installed || @config.install == :force
+          raise Vagrant::Errors::CFEngineNotInstalled if !@config.install
+
+          @machine.ui.info(I18n.t("vagrant.cfengine_installing"))
+          @machine.guest.capability(:cfengine_install, @config)
+
+          if !@machine.guest.capability(:cfengine_installed)
+            raise Vagrant::Errors::CFEngineInstallFailed
+          end
+        end
+      end
+
+      # This installs a set of files into the CFEngine folder within
+      # the machine.
+      #
+      # @param [Pathname] local_path
+      def install_files(local_path)
+        @logger.debug("Copying local files to CFEngine: #{local_path}")
+        @machine.communicate.sudo("rm -rf /tmp/cfengine-files")
+        @machine.communicate.upload(local_path.to_s, "/tmp/cfengine-files")
+        @machine.communicate.sudo("cp -R /tmp/cfengine-files/* /var/cfengine")
+      end
+    end
+  end
+end

data/plugins/provisioners/chef/config/base.rb

@@ -0,0 +1,85 @@
+module VagrantPlugins
+  module Chef
+    module Config
+      class Base < Vagrant.plugin("2", :config)
+        attr_accessor :arguments
+        attr_accessor :attempts
+        attr_accessor :binary_path
+        attr_accessor :binary_env
+        attr_accessor :http_proxy
+        attr_accessor :http_proxy_user
+        attr_accessor :http_proxy_pass
+        attr_accessor :https_proxy
+        attr_accessor :https_proxy_user
+        attr_accessor :https_proxy_pass
+        attr_accessor :json
+        attr_accessor :log_level
+        attr_accessor :no_proxy
+        attr_accessor :node_name
+        attr_accessor :provisioning_path
+        attr_accessor :run_list
+
+        def initialize
+          super
+
+          @arguments         = UNSET_VALUE
+          @attempts          = UNSET_VALUE
+          @binary_path       = UNSET_VALUE
+          @binary_env        = UNSET_VALUE
+          @http_proxy        = UNSET_VALUE
+          @http_proxy_user   = UNSET_VALUE
+          @http_proxy_pass   = UNSET_VALUE
+          @https_proxy       = UNSET_VALUE
+          @https_proxy_user  = UNSET_VALUE
+          @https_proxy_pass  = UNSET_VALUE
+          @log_level         = UNSET_VALUE
+          @no_proxy          = UNSET_VALUE
+          @node_name         = UNSET_VALUE
+          @provisioning_path = UNSET_VALUE
+
+          @json              = {}
+          @run_list          = []
+        end
+
+        def finalize!
+          @arguments         = nil if @arguments == UNSET_VALUE
+          @attempts          = 1 if @attempts == UNSET_VALUE
+          @binary_path       = nil if @binary_path == UNSET_VALUE
+          @binary_env        = nil if @binary_env == UNSET_VALUE
+          @http_proxy        = nil if @http_proxy == UNSET_VALUE
+          @http_proxy_user   = nil if @http_proxy_user == UNSET_VALUE
+          @http_proxy_pass   = nil if @http_proxy_pass == UNSET_VALUE
+          @https_proxy       = nil if @https_proxy == UNSET_VALUE
+          @https_proxy_user  = nil if @https_proxy_user == UNSET_VALUE
+          @https_proxy_pass  = nil if @https_proxy_pass == UNSET_VALUE
+          @log_level         = :info if @log_level == UNSET_VALUE
+          @no_proxy          = nil if @no_proxy == UNSET_VALUE
+          @node_name         = nil if @node_name == UNSET_VALUE
+          @provisioning_path = nil if @provisioning_path == UNSET_VALUE
+
+          # Make sure the log level is a symbol
+          @log_level = @log_level.to_sym
+        end
+
+        def merge(other)
+          super.tap do |result|
+            result.instance_variable_set(:@json, @json.merge(other.json))
+            result.instance_variable_set(:@run_list, (@run_list + other.run_list))
+          end
+        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
+      end
+    end
+  end
+end

data/plugins/provisioners/chef/config/chef_client.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module Chef
+    module Config
+      class ChefClient < Base
+        attr_accessor :chef_server_url
+        attr_accessor :client_key_path
+        attr_accessor :encrypted_data_bag_secret_key_path
+        attr_accessor :encrypted_data_bag_secret
+        attr_accessor :environment
+        attr_accessor :file_cache_path
+        attr_accessor :file_backup_path
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+
+        def initialize
+          super
+
+          @chef_server_url                    = UNSET_VALUE
+          @client_key_path                    = UNSET_VALUE
+          @encrypted_data_bag_secret_key_path = UNSET_VALUE
+          @encrypted_data_bag_secret          = UNSET_VALUE
+          @environment                        = UNSET_VALUE
+          @file_cache_path                    = UNSET_VALUE
+          @file_backup_path                   = UNSET_VALUE
+          @validation_key_path                = UNSET_VALUE
+          @validation_client_name             = UNSET_VALUE
+        end
+
+        def finalize!
+          super
+
+          @chef_server_url = nil if @chef_server_url == UNSET_VALUE
+          @client_key_path        = "/etc/chef/client.pem" if @client_key_path == UNSET_VALUE
+          @encrypted_data_bag_secret_key_path = nil if @encrypted_data_bag_secret_key_path == UNSET_VALUE
+          @encrypted_data_bag_secret          = "/tmp/encrypted_data_bag_secret" if @encrypted_data_bag_secret == UNSET_VALUE
+          @environment = nil if @environment == UNSET_VALUE
+          @file_backup_path       = "/srv/chef/cache" if @file_backup_path == UNSET_VALUE
+          @file_cache_path        = "/srv/chef/file_store" if @file_cache_path == UNSET_VALUE
+          @validation_client_name = "chef-validator" if @validation_client_name == UNSET_VALUE
+          @validation_key_path = nil if @validation_key_path == UNSET_VALUE
+        end
+
+        def validate(machine)
+          errors = _detected_errors
+          errors << I18n.t("vagrant.config.chef.server_url_empty") if \
+            !chef_server_url || chef_server_url.strip == ""
+          errors << I18n.t("vagrant.config.chef.validation_key_path") if \
+            !validation_key_path
+
+          { "chef client provisioner" => errors }
+        end
+      end
+    end
+  end
+end