chef 12.10.24-universal-mingw32 → 12.11.18-universal-mingw32

data/distro/common/markdown/README

@@ -1,3 +1,3 @@
-This directory contains markdown documentation that is used in other places.
-For example, markdown (.mkd) documents that are generated as man pages
-with ronn.
+This directory contains markdown documentation that is used in other places.
+For example, markdown (.mkd) documents that are generated as man pages
+with ronn.

data/lib/chef/application.rb

@@ -27,6 +27,7 @@ require "chef/platform"
 require "mixlib/cli"
 require "tmpdir"
 require "rbconfig"
+require "chef/application/exit_code"
 
 class Chef
   class Application
@@ -60,11 +61,11 @@ class Chef
 
     def setup_signal_handlers
       trap("INT") do
-        Chef::Application.fatal!("SIGINT received, stopping", 2)
+        Chef::Application.fatal!("SIGINT received, stopping", Chef::Exceptions::SigInt.new)
       end
 
       trap("TERM") do
-        Chef::Application.fatal!("SIGTERM received, stopping", 3)
+        Chef::Application.fatal!("SIGTERM received, stopping", Chef::Exceptions::SigTerm.new)
       end
 
       unless Chef::Platform.windows?
@@ -149,7 +150,7 @@ class Chef
       Chef::Log.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})")
-      Chef::Application.fatal!("Aborting due to invalid 'log_location' configuration", 2)
+      Chef::Application.fatal!("Aborting due to invalid 'log_location' configuration", error)
     end
 
     # Turn `log_location :syslog` and `log_location :win_evt` into the
@@ -285,7 +286,7 @@ class Chef
           @chef_client.run
         rescue Exception => e
           Chef::Log.error(e.to_s)
-          exit 1
+          exit Chef::Application.normalize_exit_code(e)
         else
           exit 0
         end
@@ -314,7 +315,7 @@ class Chef
       Chef::Log.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 ) }
-      Chef::Application.fatal!("Aborting due to error in '#{config_file_path}'", 2)
+      Chef::Application.fatal!("Aborting due to error in '#{config_file_path}'", error)
     end
 
     # This is a hook for testing
@@ -341,15 +342,19 @@ class Chef
         true
       end
 
+      def normalize_exit_code(exit_code)
+        Chef::Application::ExitCode.normalize_exit_code(exit_code)
+      end
+
       # Log a fatal error message to both STDERR and the Logger, exit the application
-      def fatal!(msg, err = -1)
+      def fatal!(msg, err = nil)
         Chef::Log.fatal(msg)
-        Process.exit err
+        Process.exit(normalize_exit_code(err))
       end
 
-      def exit!(msg, err = -1)
+      def exit!(msg, err = nil)
         Chef::Log.debug(msg)
-        Process.exit err
+        Process.exit(normalize_exit_code(err))
       end
     end
 

data/lib/chef/application/apply.rb

@@ -137,11 +137,11 @@ class Chef::Application::Apply < Chef::Application
 
   def read_recipe_file(file_name)
     if file_name.nil?
-      Chef::Application.fatal!("No recipe file was provided", 1)
+      Chef::Application.fatal!("No recipe file was provided", Chef::Exceptions::RecipeNotFound.new)
     else
       recipe_path = File.expand_path(file_name)
       unless File.exist?(recipe_path)
-        Chef::Application.fatal!("No file exists at #{recipe_path}", 1)
+        Chef::Application.fatal!("No file exists at #{recipe_path}", Chef::Exceptions::RecipeNotFound.new)
       end
       recipe_fh = open(recipe_path)
       recipe_text = recipe_fh.read
@@ -150,7 +150,7 @@ class Chef::Application::Apply < Chef::Application
   end
 
   def get_recipe_and_run_context
-    Chef::Config[:solo] = true
+    Chef::Config[:solo_legacy_mode] = true
     @chef_client = Chef::Client.new(@json_attribs)
     @chef_client.run_ohai
     @chef_client.load_node
@@ -183,7 +183,7 @@ class Chef::Application::Apply < Chef::Application
     else
       if !ARGV[0]
         puts opt_parser
-        Chef::Application.exit! "No recipe file provided", 1
+        Chef::Application.exit! "No recipe file provided", Chef::Exceptions::RecipeNotFound.new
       end
       @recipe_filename = ARGV[0]
       @recipe_text, @recipe_fh = read_recipe_file @recipe_filename
@@ -208,7 +208,7 @@ class Chef::Application::Apply < Chef::Application
       raise
     rescue Exception => e
       Chef::Application.debug_stacktrace(e)
-      Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+      Chef::Application.fatal!("#{e.class}: #{e.message}", e)
     end
   end
 

data/lib/chef/application/client.rb

@@ -324,7 +324,7 @@ class Chef::Application::Client < Chef::Application
 
     if Chef::Config[:recipe_url]
       if !Chef::Config.local_mode
-        Chef::Application.fatal!("chef-client recipe-url can be used only in local-mode", 1)
+        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"
@@ -420,7 +420,7 @@ class Chef::Application::Client < Chef::Application
       rescue SystemExit
         raise
       rescue Exception => e
-        Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+        Chef::Application.fatal!("#{e.class}: #{e.message}", e)
       end
     else
       interval_run_chef_client
@@ -463,7 +463,7 @@ class Chef::Application::Client < Chef::Application
       retry
     end
 
-    Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+    Chef::Application.fatal!("#{e.class}: #{e.message}", e)
   end
 
   def test_signal

data/lib/chef/application/exit_code.rb

@@ -0,0 +1,226 @@
+#
+# Author:: Steven Murawski (<smurawski@chef.io>)
+# Copyright:: Copyright 2016, Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Chef
+  class Application
+
+    # These are the exit codes defined in Chef RFC 062
+    # https://github.com/chef/chef-rfc/blob/master/rfc062-exit-status.md
+    class ExitCode
+
+      # -1 is defined as DEPRECATED_FAILURE in RFC 062, so it is
+      # not enumerated in an active constant.
+      #
+      VALID_RFC_062_EXIT_CODES = {
+        SUCCESS: 0,
+        GENERIC_FAILURE: 1,
+        SIGINT_RECEIVED: 2,
+        SIGTERM_RECEIVED: 3,
+        REBOOT_SCHEDULED: 35,
+        REBOOT_NEEDED: 37,
+        REBOOT_FAILED: 41,
+        AUDIT_MODE_FAILURE: 42,
+      }
+
+      DEPRECATED_RFC_062_EXIT_CODES = {
+        DEPRECATED_FAILURE: -1,
+      }
+
+      class << self
+
+        def normalize_exit_code(exit_code = nil)
+          if normalization_not_configured?
+            normalize_legacy_exit_code_with_warning(exit_code)
+          elsif normalization_disabled?
+            normalize_legacy_exit_code(exit_code)
+          else
+            normalize_exit_code_to_rfc(exit_code)
+          end
+        end
+
+        def enforce_rfc_062_exit_codes?
+          !normalization_disabled? && !normalization_not_configured?
+        end
+
+        def notify_reboot_exit_code_deprecation
+          return if normalization_disabled?
+          notify_on_deprecation(reboot_deprecation_warning)
+        end
+
+        def notify_deprecated_exit_code
+          return if normalization_disabled?
+          notify_on_deprecation(deprecation_warning)
+        end
+
+        private
+
+        def normalization_disabled?
+          Chef::Config[:exit_status] == :disabled
+        end
+
+        def normalization_not_configured?
+          Chef::Config[:exit_status].nil?
+        end
+
+        def normalize_legacy_exit_code_with_warning(exit_code)
+          normalized_exit_code = normalize_legacy_exit_code(exit_code)
+          unless valid_exit_codes.include? normalized_exit_code
+            notify_on_deprecation(deprecation_warning)
+          end
+          normalized_exit_code
+        end
+
+        def normalize_legacy_exit_code(exit_code)
+          case exit_code
+          when Fixnum
+            exit_code
+          when Exception
+            lookup_exit_code_by_exception(exit_code)
+          else
+            default_exit_code
+          end
+        end
+
+        def normalize_exit_code_to_rfc(exit_code)
+          normalized_exit_code = normalize_legacy_exit_code_with_warning(exit_code)
+          if valid_exit_codes.include? normalized_exit_code
+            normalized_exit_code
+          else
+            VALID_RFC_062_EXIT_CODES[:GENERIC_FAILURE]
+          end
+        end
+
+        def lookup_exit_code_by_exception(exception)
+          if sigint_received?(exception)
+            VALID_RFC_062_EXIT_CODES[:SIGINT_RECEIVED]
+          elsif sigterm_received?(exception)
+            VALID_RFC_062_EXIT_CODES[:SIGTERM_RECEIVED]
+          elsif normalization_disabled? || normalization_not_configured?
+            if legacy_exit_code?(exception)
+              # We have lots of "Chef::Application.fatal!('', 2)
+              # This maintains that behavior at initial introduction
+              # and when the RFC exit_status compliance is disabled.
+              VALID_RFC_062_EXIT_CODES[:SIGINT_RECEIVED]
+            else
+              VALID_RFC_062_EXIT_CODES[:GENERIC_FAILURE]
+            end
+          elsif reboot_scheduled?(exception)
+            VALID_RFC_062_EXIT_CODES[:REBOOT_SCHEDULED]
+          elsif reboot_needed?(exception)
+            VALID_RFC_062_EXIT_CODES[:REBOOT_NEEDED]
+          elsif reboot_failed?(exception)
+            VALID_RFC_062_EXIT_CODES[:REBOOT_FAILED]
+          elsif audit_failure?(exception)
+            VALID_RFC_062_EXIT_CODES[:AUDIT_MODE_FAILURE]
+          else
+            VALID_RFC_062_EXIT_CODES[:GENERIC_FAILURE]
+          end
+        end
+
+        def legacy_exit_code?(exception)
+          resolve_exception_array(exception).any? do |e|
+            e.is_a? Chef::Exceptions::DeprecatedExitCode
+          end
+        end
+
+        def reboot_scheduled?(exception)
+          resolve_exception_array(exception).any? do |e|
+            e.is_a? Chef::Exceptions::Reboot
+          end
+        end
+
+        def reboot_needed?(exception)
+          resolve_exception_array(exception).any? do |e|
+            e.is_a? Chef::Exceptions::RebootPending
+          end
+        end
+
+        def reboot_failed?(exception)
+          resolve_exception_array(exception).any? do |e|
+            e.is_a? Chef::Exceptions::RebootFailed
+          end
+        end
+
+        def audit_failure?(exception)
+          resolve_exception_array(exception).any? do |e|
+            e.is_a? Chef::Exceptions::AuditError
+          end
+        end
+
+        def sigint_received?(exception)
+          resolve_exception_array(exception).any? do |e|
+            e.is_a? Chef::Exceptions::SigInt
+          end
+        end
+
+        def sigterm_received?(exception)
+          resolve_exception_array(exception).any? do |e|
+            e.is_a? Chef::Exceptions::SigTerm
+          end
+        end
+
+        def resolve_exception_array(exception)
+          exception_array = [exception]
+          if exception.respond_to?(:wrapped_errors)
+            exception.wrapped_errors.each do |e|
+              exception_array.push e
+            end
+          end
+          exception_array
+        end
+
+        def valid_exit_codes
+          VALID_RFC_062_EXIT_CODES.values
+        end
+
+        def notify_on_deprecation(message)
+          begin
+            Chef.log_deprecation(message)
+          rescue Chef::Exceptions::DeprecatedFeatureError
+            # Have to rescue this, otherwise this unhandled error preempts
+            # the current exit code assignment.
+          end
+        end
+
+        def deprecation_warning
+          "Chef RFC 062 (https://github.com/chef/chef-rfc/master/rfc062-exit-status.md) defines the" \
+          " exit codes that should be used with Chef.  Chef::Application::ExitCode defines valid exit codes"  \
+          " In a future release, non-standard exit codes will be redefined as" \
+          " GENERIC_FAILURE unless `exit_status` is set to `:disabled` in your client.rb."
+        end
+
+        def reboot_deprecation_warning
+          "Per RFC 062 (https://github.com/chef/chef-rfc/blob/master/rfc062-exit-status.md)" \
+          ", when a reboot is requested Chef Client will exit with an exit code of 35, REBOOT_SCHEDULED." \
+          " To maintain the current behavior (an exit code of 0), you will need to set `exit_status` to" \
+          " `:disabled` in your client.rb"
+        end
+
+        def default_exit_code
+          if normalization_disabled? || normalization_not_configured?
+            return DEPRECATED_RFC_062_EXIT_CODES[:DEPRECATED_FAILURE]
+          else
+            VALID_RFC_062_EXIT_CODES[:GENERIC_FAILURE]
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/lib/chef/application/solo.rb

@@ -18,6 +18,7 @@
 
 require "chef"
 require "chef/application"
+require "chef/application/client"
 require "chef/client"
 require "chef/config"
 require "chef/daemon"
@@ -200,10 +201,24 @@ class Chef::Application::Solo < Chef::Application
     :description    => "DANGEROUS: does what it says, only useful with --recipe-url",
     :boolean        => true
 
+  option :solo_legacy_mode,
+    :long           => "--legacy-mode",
+    :description    => "Run chef-solo in legacy mode",
+    :boolean        => true
+
   attr_reader :chef_client_json
 
-  def initialize
-    super
+  # Get this party started
+  def run
+    setup_signal_handlers
+    reconfigure
+    for_ezra if Chef::Config[:ez]
+    if !Chef::Config[:solo_legacy_mode]
+      Chef::Application::Client.new.run
+    else
+      setup_application
+      run_application
+    end
   end
 
   def reconfigure
@@ -215,14 +230,30 @@ class Chef::Application::Solo < Chef::Application
 
     Chef::Config[:solo] = true
 
+    Chef::Log.deprecation("-r MUST be changed to --recipe-url, the -r option will be changed in Chef 13.0") if ARGV.include?("-r")
+
+    if !Chef::Config[:solo_legacy_mode]
+      # Because we re-parse ARGV when we move to chef-client, we need to tidy up some options first.
+      ARGV.delete("--ez")
+
+      # -r means something entirely different in chef-client land, so let's replace it with a "safe" value
+      if dash_r = ARGV.index("-r")
+        ARGV[dash_r] = "--recipe-url"
+      end
+
+      Chef::Config[:local_mode] = true
+    else
+      configure_legacy_mode!
+    end
+  end
+
+  def configure_legacy_mode!
     if Chef::Config[:daemonize]
       Chef::Config[:interval] ||= 1800
     end
 
     Chef::Application.fatal!(unforked_interval_error_message) if !Chef::Config[:client_fork] && Chef::Config[:interval]
 
-    Chef::Log.deprecation("-r MUST be changed to --recipe-url, the -r option will be changed in Chef 13.0") if ARGV.include?("-r")
-
     if Chef::Config[:recipe_url]
       cookbooks_path = Array(Chef::Config[:cookbook_path]).detect { |e| Pathname.new(e).cleanpath.to_s =~ /\/cookbooks\/*$/ }
       recipes_path = File.expand_path(File.join(cookbooks_path, ".."))
@@ -255,7 +286,6 @@ class Chef::Application::Solo < Chef::Application
   end
 
   def run_application
-    for_ezra if Chef::Config[:ez]
     if !Chef::Config[:client_fork] || Chef::Config[:once]
       # Run immediately without interval sleep or splay
       begin
@@ -263,7 +293,7 @@ class Chef::Application::Solo < Chef::Application
       rescue SystemExit
         raise
       rescue Exception => e
-        Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+        Chef::Application.fatal!("#{e.class}: #{e.message}", e)
       end
     else
       interval_run_chef_client
@@ -310,7 +340,7 @@ EOH
           Chef::Log.debug("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
           retry
         else
-          Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+          Chef::Application.fatal!("#{e.class}: #{e.message}", e)
         end
       end
     end