chef 13.12.14 → 14.0.190

data/lib/chef/api_client.rb

@@ -83,7 +83,7 @@ class Chef
 
     # Gets or sets whether this client is a validator.
     #
-    # @param [Boolean] whether or not the client is a validator.  If
+    # @param [Boolean] arg whether or not the client is a validator.  If
     #   `nil`, retrieves the already-set value.
     # @return [Boolean] The current value
     def validator(arg = nil)

data/lib/chef/api_client/registration.rb

@@ -19,6 +19,7 @@
 require "chef/config"
 require "chef/server_api"
 require "chef/exceptions"
+require "fileutils"
 
 class Chef
   class ApiClient
@@ -69,8 +70,15 @@ class Chef
       end
 
       def assert_destination_writable!
-        if (File.exists?(destination) && !File.writable?(destination)) || !File.writable?(File.dirname(destination))
-          abs_path = File.expand_path(destination)
+        abs_path = File.expand_path(destination)
+        if !File.exists?(File.dirname(abs_path))
+          begin
+            FileUtils.mkdir_p(File.dirname(abs_path))
+          rescue Errno::EACCES
+            raise Chef::Exceptions::CannotWritePrivateKey, "I can't create the configuration directory at #{File.dirname(abs_path)} - check permissions?"
+          end
+        end
+        if (File.exists?(abs_path) && !File.writable?(abs_path)) || !File.writable?(File.dirname(abs_path))
           raise Chef::Exceptions::CannotWritePrivateKey, "I can't write your private key to #{abs_path} - check permissions?"
         end
       end

data/lib/chef/api_client_v1.rb

@@ -70,7 +70,7 @@ class Chef
 
     # Gets or sets the client name.
     #
-    # @param [Optional String] The name must be alpha-numeric plus - and _.
+    # @param arg [Optional String] The name must be alpha-numeric plus - and _.
     # @return [String] The current value of the name.
     def name(arg = nil)
       set_or_return(
@@ -82,7 +82,7 @@ class Chef
 
     # Gets or sets whether this client is an admin.
     #
-    # @param [Optional True/False] Should be true or false - default is false.
+    # @param arg [Optional True/False] Should be true or false - default is false.
     # @return [True/False] The current value
     def admin(arg = nil)
       set_or_return(
@@ -94,7 +94,7 @@ class Chef
 
     # Gets or sets the public key.
     #
-    # @param [Optional String] The string representation of the public key.
+    # @param arg [Optional String] The string representation of the public key.
     # @return [String] The current value.
     def public_key(arg = nil)
       set_or_return(
@@ -106,7 +106,7 @@ class Chef
 
     # Gets or sets whether this client is a validator.
     #
-    # @param [Boolean] whether or not the client is a validator.  If
+    # @param arg [Boolean] whether or not the client is a validator.  If
     #   `nil`, retrieves the already-set value.
     # @return [Boolean] The current value
     def validator(arg = nil)
@@ -120,7 +120,7 @@ class Chef
     # Private key. The server will return it as a string.
     # Set to true under API V0 to have the server regenerate the default key.
     #
-    # @param [Optional String] The string representation of the private key.
+    # @param arg [Optional String] The string representation of the private key.
     # @return [String] The current value.
     def private_key(arg = nil)
       set_or_return(
@@ -132,7 +132,7 @@ class Chef
 
     # Used to ask server to generate key pair under api V1
     #
-    # @param [Optional True/False] Should be true or false - default is false.
+    # @param arg [Optional True/False] Should be true or false - default is false.
     # @return [True/False] The current value
     def create_key(arg = nil)
       set_or_return(
@@ -200,6 +200,7 @@ class Chef
     end
 
     # Load a client by name via the API
+    # @param name [String] the client name
     def self.load(name)
       response = http_api.get("clients/#{name}")
       Chef::ApiClientV1.from_hash(response)

data/lib/chef/application.rb

@@ -43,8 +43,15 @@ class Chef
       # from failing due to permissions when launched as a less privileged user.
     end
 
+    # Configure mixlib-cli to always separate defaults from user-supplied CLI options
+    def self.use_separate_defaults?
+      true
+    end
+
     # Reconfigure the application. You'll want to override and super this method.
     def reconfigure
+      # In case any gems were installed for use in the config.
+      Gem.clear_paths
       configure_chef
       configure_logging
       configure_encoding
@@ -70,33 +77,54 @@ class Chef
 
       unless Chef::Platform.windows?
         trap("QUIT") do
-          Chef::Log.info("SIGQUIT received, call stack:\n  " + caller.join("\n  "))
+          logger.info("SIGQUIT received, call stack:\n  " + caller.join("\n  "))
         end
 
         trap("HUP") do
-          Chef::Log.info("SIGHUP received, reconfiguring")
+          logger.info("SIGHUP received, reconfiguring")
           reconfigure
         end
       end
     end
 
     def emit_warnings
-      Chef::Log.warn "Chef::Config[:zypper_check_gpg] is set to false which disables security checking on zypper packages" unless Chef::Config[:zypper_check_gpg]
+      logger.warn "chef_config[:zypper_check_gpg] is set to false which disables security checking on zypper packages" unless chef_config[:zypper_check_gpg]
     end
 
     # Parse configuration (options and config file)
     def configure_chef
       parse_options
       load_config_file
-      Chef::Config.export_proxies
-      Chef::Config.init_openssl
-      File.umask Chef::Config[:umask]
+      chef_config.export_proxies
+      chef_config.init_openssl
+      File.umask chef_config[:umask]
+    end
+
+    # @api private (test injection)
+    def chef_config
+      Chef::Config
+    end
+
+    # @api private (test injection)
+    def logger
+      Chef::Log
+    end
+
+    def self.logger
+      Chef::Log
+    end
+
+    # @api private (test injection)
+    def chef_configfetcher
+      Chef::ConfigFetcher
     end
 
     # Parse the config file
     def load_config_file
-      config_fetcher = Chef::ConfigFetcher.new(config[:config_file])
+      # apply the default cli options first
+      chef_config.merge!(default_config)
 
+      config_fetcher = chef_configfetcher.new(config[:config_file])
       # Some config settings are derived relative to the config file path; if
       # given as a relative path, this is computed relative to cwd, but
       # chef-client will later chdir to root, so we need to get the absolute path
@@ -104,29 +132,29 @@ class Chef
       config[:config_file] = config_fetcher.expanded_path
 
       if config[:config_file].nil?
-        Chef::Log.warn("No config file found or specified on command line, using command line options.")
+        logger.warn("No config file found or specified on command line, using command line options.")
       elsif config_fetcher.config_missing?
-        Chef::Log.warn("*****************************************")
-        Chef::Log.warn("Did not find config file: #{config[:config_file]}, using command line options.")
-        Chef::Log.warn("*****************************************")
+        logger.warn("*****************************************")
+        logger.warn("Did not find config file: #{config[:config_file]}, using command line options.")
+        logger.warn("*****************************************")
       else
         config_content = config_fetcher.read_config
         apply_config(config_content, config[:config_file])
       end
       extra_config_options = config.delete(:config_option)
-      Chef::Config.merge!(config)
+      chef_config.merge!(config)
       apply_extra_config_options(extra_config_options)
     end
 
     def apply_extra_config_options(extra_config_options)
-      Chef::Config.apply_extra_config_options(extra_config_options)
+      chef_config.apply_extra_config_options(extra_config_options)
     rescue ChefConfig::UnparsableConfigOption => e
       Chef::Application.fatal!(e.message)
     end
 
     def set_specific_recipes
       if cli_arguments.respond_to?(:map)
-        Chef::Config[:specific_recipes] =
+        chef_config[:specific_recipes] =
           cli_arguments.map { |file| File.expand_path(file) }
       end
     end
@@ -150,26 +178,26 @@ class Chef
     #
     def configure_logging
       configure_log_location
-      Chef::Log.init(MonoLogger.new(Chef::Config[:log_location]))
+      logger.init(MonoLogger.new(chef_config[:log_location]))
       if want_additional_logger?
         configure_stdout_logger
       end
-      Chef::Log.level = resolve_log_level
+      logger.level = resolve_log_level
     rescue StandardError => error
-      Chef::Log.fatal("Failed to open or create log file at #{Chef::Config[:log_location]}: #{error.class} (#{error.message})")
+      logger.fatal("Failed to open or create log file at #{chef_config[:log_location]}: #{error.class} (#{error.message})")
       Chef::Application.fatal!("Aborting due to invalid 'log_location' configuration", error)
     end
 
     # Turn `log_location :syslog` and `log_location :win_evt` into the
     # appropriate loggers.
     def configure_log_location
-      log_location = Chef::Config[:log_location]
+      log_location = chef_config[:log_location]
       return unless log_location.respond_to?(:to_sym)
 
-      Chef::Config[:log_location] =
+      chef_config[:log_location] =
         case log_location.to_sym
-          when :syslog then Chef::Log::Syslog.new
-          when :win_evt then Chef::Log::WinEvt.new
+          when :syslog then logger::Syslog.new
+          when :win_evt then logger::WinEvt.new
           else log_location # Probably a path; let MonoLogger sort it out
         end
     end
@@ -177,22 +205,22 @@ class Chef
     # Based on config and whether or not STDOUT is a tty, should we setup a
     # secondary logger for stdout?
     def want_additional_logger?
-      Chef::Config.is_default?(:log_location) && Chef::Config[:log_location].tty? && !Chef::Config[:daemonize]
+      !( chef_config[:log_location].is_a?(IO) && chef_config[:log_location].tty? ) && !chef_config[:daemonize]
     end
 
     def configure_stdout_logger
       stdout_logger = MonoLogger.new(STDOUT)
-      stdout_logger.formatter = Chef::Log.logger.formatter
-      Chef::Log.loggers << stdout_logger
+      stdout_logger.formatter = logger.logger.formatter
+      logger.loggers << stdout_logger
     end
 
     # Use of output formatters is assumed if `force_formatter` is set or if `force_logger` is not set
     def using_output_formatter?
-      Chef::Config[:force_formatter] || !Chef::Config[:force_logger]
+      chef_config[:force_formatter] || !chef_config[:force_logger]
     end
 
     def auto_log_level?
-      Chef::Config[:log_level] == :auto
+      chef_config[:log_level] == :auto
     end
 
     # if log_level is `:auto`, convert it to :warn (when using output formatter)
@@ -205,13 +233,13 @@ class Chef
           :info
         end
       else
-        Chef::Config[:log_level]
+        chef_config[:log_level]
       end
     end
 
     # Sets the default external encoding to UTF-8 (users can change this, but they shouldn't)
     def configure_encoding
-      Encoding.default_external = Chef::Config[:ruby_encoding]
+      Encoding.default_external = chef_config[:ruby_encoding]
     end
 
     # Called prior to starting the application, by the run method
@@ -237,7 +265,8 @@ class Chef
           @chef_client_json,
           override_runlist: override_runlist,
           specific_recipes: specific_recipes,
-          runlist: config[:runlist]
+          runlist: config[:runlist],
+          logger: logger
         )
         @chef_client_json = nil
 
@@ -259,7 +288,7 @@ class Chef
       # win32-process gem exposes some form of :fork for Process
       # class. So we are separately ensuring that the platform we're
       # running on is not windows before forking.
-      Chef::Config[:client_fork] && Process.respond_to?(:fork) && !Chef::Platform.windows?
+      chef_config[:client_fork] && Process.respond_to?(:fork) && !Chef::Platform.windows?
     end
 
     # Run chef-client once and then exit. If TERM signal is received, ignores the
@@ -267,7 +296,7 @@ class Chef
     def run_with_graceful_exit_option
       # Override the TERM signal.
       trap("TERM") do
-        Chef::Log.debug("SIGTERM received during converge," +
+        logger.debug("SIGTERM received during converge," +
           " finishing converge to exit normally (send SIGINT to terminate immediately)")
       end
 
@@ -276,31 +305,31 @@ class Chef
     end
 
     def fork_chef_client
-      Chef::Log.info "Forking chef instance to converge..."
+      logger.info "Forking chef instance to converge..."
       pid = fork do
         # Want to allow forked processes to finish converging when
         # TERM singal is received (exit gracefully)
         trap("TERM") do
-          Chef::Log.debug("SIGTERM received during converge," +
+          logger.debug("SIGTERM received during converge," +
             " finishing converge to exit normally (send SIGINT to terminate immediately)")
         end
 
-        client_solo = Chef::Config[:solo] ? "chef-solo" : "chef-client"
+        client_solo = chef_config[:solo] ? "chef-solo" : "chef-client"
         $0 = "#{client_solo} worker: ppid=#{Process.ppid};start=#{Time.new.strftime("%R:%S")};"
         begin
-          Chef::Log.debug "Forked instance now converging"
+          logger.trace "Forked instance now converging"
           @chef_client.run
         rescue Exception => e
-          Chef::Log.error(e.to_s)
+          logger.error(e.to_s)
           exit Chef::Application.normalize_exit_code(e)
         else
           exit 0
         end
       end
-      Chef::Log.debug "Fork successful. Waiting for new chef pid: #{pid}"
+      logger.trace "Fork successful. Waiting for new chef pid: #{pid}"
       result = Process.waitpid2(pid)
       handle_child_exit(result)
-      Chef::Log.debug "Forked instance successfully reaped (pid: #{pid})"
+      logger.trace "Forked instance successfully reaped (pid: #{pid})"
       true
     end
 
@@ -316,11 +345,11 @@ class Chef
     end
 
     def apply_config(config_content, config_file_path)
-      Chef::Config.from_string(config_content, config_file_path)
+      chef_config.from_string(config_content, config_file_path)
     rescue Exception => error
-      Chef::Log.fatal("Configuration error #{error.class}: #{error.message}")
+      logger.fatal("Configuration error #{error.class}: #{error.message}")
       filtered_trace = error.backtrace.grep(/#{Regexp.escape(config_file_path)}/)
-      filtered_trace.each { |line| Chef::Log.fatal("  " + line ) }
+      filtered_trace.each { |line| logger.fatal("  " + line ) }
       Chef::Application.fatal!("Aborting due to error in '#{config_file_path}'", error)
     end
 
@@ -343,9 +372,9 @@ class Chef
         chef_stacktrace_out += message
 
         Chef::FileCache.store("chef-stacktrace.out", chef_stacktrace_out)
-        Chef::Log.fatal("Stacktrace dumped to #{Chef::FileCache.load("chef-stacktrace.out", false)}")
-        Chef::Log.fatal("Please provide the contents of the stacktrace.out file if you file a bug report")
-        Chef::Log.debug(message)
+        logger.fatal("Stacktrace dumped to #{Chef::FileCache.load("chef-stacktrace.out", false)}")
+        logger.fatal("Please provide the contents of the stacktrace.out file if you file a bug report")
+        logger.debug(message)
         true
       end
 
@@ -355,12 +384,12 @@ class Chef
 
       # Log a fatal error message to both STDERR and the Logger, exit the application
       def fatal!(msg, err = nil)
-        Chef::Log.fatal(msg)
+        logger.fatal(msg)
         Process.exit(normalize_exit_code(err))
       end
 
       def exit!(msg, err = nil)
-        Chef::Log.debug(msg)
+        logger.debug(msg)
         Process.exit(normalize_exit_code(err))
       end
     end

data/lib/chef/application/client.rb

@@ -2,7 +2,7 @@
 # Author:: AJ Christensen (<aj@chef.io)
 # Author:: Christopher Brown (<cb@chef.io>)
 # Author:: Mark Mzyk (mmzyk@chef.io)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -28,7 +28,6 @@ require "chef/workstation_config_loader"
 require "chef/mixin/shell_out"
 require "chef-config/mixin/dot_d"
 require "mixlib/archive"
-require "uri"
 
 class Chef::Application::Client < Chef::Application
   include Chef::Mixin::ShellOut
@@ -229,8 +228,7 @@ class Chef::Application::Client < Chef::Application
   option :client_fork,
     :short        => "-f",
     :long         => "--[no-]fork",
-    :description  => "Fork client",
-    :boolean      => true
+    :description  => "Fork client"
 
   option :recipe_url,
     :long         => "--recipe-url=RECIPE_URL",
@@ -338,14 +336,16 @@ class Chef::Application::Client < Chef::Application
         Chef::Application.fatal!("chef-client recipe-url can be used only in local-mode")
       else
         if Chef::Config[:delete_entire_chef_repo]
-          Chef::Log.debug "Cleanup path #{Chef::Config.chef_repo_path} before extract recipes into it"
+          Chef::Log.trace "Cleanup path #{Chef::Config.chef_repo_path} before extract recipes into it"
           FileUtils.rm_rf(recipes_path, :secure => true)
         end
-        Chef::Log.debug "Creating path #{Chef::Config.chef_repo_path} to extract recipes into"
+        Chef::Log.trace "Creating path #{Chef::Config.chef_repo_path} to extract recipes into"
         FileUtils.mkdir_p(Chef::Config.chef_repo_path)
         tarball_path = File.join(Chef::Config.chef_repo_path, "recipes.tgz")
         fetch_recipe_tarball(Chef::Config[:recipe_url], tarball_path)
         Mixlib::Archive.new(tarball_path).extract(Chef::Config.chef_repo_path, perms: false, ignore: /^\.$/)
+        config_path = File.join(Chef::Config.chef_repo_path, ".chef/config.rb")
+        Chef::Config.from_string(IO.read(config_path), config_path) if File.file?(config_path)
       end
     end
 
@@ -361,6 +361,11 @@ class Chef::Application::Client < Chef::Application
       Chef::Config[:splay] = nil
     end
 
+    # supervisor processes are enabled by default for interval-running processes but not for one-shot runs
+    if Chef::Config[:client_fork].nil?
+      Chef::Config[:client_fork] = !!Chef::Config[:interval]
+    end
+
     if !Chef::Config[:client_fork] && Chef::Config[:interval] && !Chef::Platform.windows?
       Chef::Application.fatal!(unforked_interval_error_message)
     end
@@ -462,7 +467,7 @@ class Chef::Application::Client < Chef::Application
   end
 
   def sleep_then_run_chef_client(sleep_sec)
-    Chef::Log.debug("Sleeping for #{sleep_sec} seconds")
+    Chef::Log.trace("Sleeping for #{sleep_sec} seconds")
 
     # interval_sleep will return early if we received a signal (unless on windows)
     interval_sleep(sleep_sec)
@@ -475,7 +480,7 @@ class Chef::Application::Client < Chef::Application
   rescue Exception => e
     if Chef::Config[:interval]
       Chef::Log.error("#{e.class}: #{e}")
-      Chef::Log.debug("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
+      Chef::Log.trace("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
       retry
     end
 
@@ -528,18 +533,11 @@ class Chef::Application::Client < Chef::Application
   end
 
   def fetch_recipe_tarball(url, path)
-    Chef::Log.debug("Download recipes tarball from #{url} to #{path}")
-    if File.exist?(url)
-      FileUtils.cp(url, path)
-    elsif url =~ URI.regexp
-      File.open(path, "wb") do |f|
-        open(url) do |r|
-          f.write(r.read)
-        end
+    Chef::Log.trace("Download recipes tarball from #{url} to #{path}")
+    File.open(path, "wb") do |f|
+      open(url) do |r|
+        f.write(r.read)
       end
-    else
-      Chef::Application.fatal! "You specified --recipe-url but the value is neither a valid URL nor a path to a file that exists on disk." +
-        "Please confirm the location of the tarball and try again."
     end
   end
 end