chef 16.1.16 → 16.18.30

data/lib/chef/mixin/deep_merge.rb

@@ -19,16 +19,33 @@
 
 class Chef
   module Mixin
-    # == Chef::Mixin::DeepMerge
     # Implements a deep merging algorithm for nested data structures.
-    # ==== Notice:
-    #   This code was originally imported from deep_merge by Steve Midgley.
-    #   deep_merge is available under the MIT license from
-    #   http://trac.misuse.org/science/wiki/DeepMerge
+    #
+    # This code was originally imported from deep_merge by Steve Midgley.
+    # deep_merge is available under the MIT license from
+    # http://trac.misuse.org/science/wiki/DeepMerge
+    #
+    # Note that this is not considered a public interface.  It is technically
+    # public and has been used and we cannot break the API, but continued
+    # external use is discouraged.  We are unlikely to change the shape of
+    # the API and break anyone, but this code does not serve the purposes of
+    # cookbook authors and customers.  It is intended only for the purposes
+    # of the internal use in the chef-client codebase.  We do not accept
+    # pull requests to extend the functionality of this algorithm.  Users
+    # who find this does nearly what they want, should copy and paste the
+    # algorithm and tune to their needs.  We will not maintain any additional
+    # use cases.
+    #
+    # "It is what it is, and if it isn't what you want, you need to build
+    # that yourself"
+    #
+    # @api private
+    #
     module DeepMerge
 
       extend self
 
+      # @api private
       def merge(first, second)
         first  = Mash.new(first)  unless first.is_a?(Mash)
         second = Mash.new(second) unless second.is_a?(Mash)
@@ -38,29 +55,27 @@ class Chef
 
       class InvalidParameter < StandardError; end
 
-      # Deep Merge core documentation.
       # deep_merge! method permits merging of arbitrary child elements. The two top level
       # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
       # of child elements. These child elements to not have to be of the same types.
       # Where child elements are of the same type, deep_merge will attempt to merge them together.
       # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
       # the destination element with the contents of the source element at that level.
+      #
       # So if you have two hashes like this:
+      #
       #   source = {:x => [1,2,3], :y => 2}
       #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
       #   dest.deep_merge!(source)
       #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+      #
       # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
       # To avoid this, use "deep_merge" (no bang/exclamation mark)
+      #
+      # @api private
+      #
       def deep_merge!(source, dest)
-        # if dest doesn't exist, then simply copy source to it
-        if dest.nil?
-          dest = source; return dest
-        end
-
         case source
-        when nil
-          dest
         when Hash
           if dest.is_a?(Hash)
             source.each do |src_key, src_value|
@@ -87,10 +102,12 @@ class Chef
         dest
       end # deep_merge!
 
+      # @api private
       def hash_only_merge(merge_onto, merge_with)
         hash_only_merge!(safe_dup(merge_onto), safe_dup(merge_with))
       end
 
+      # @api private
       def safe_dup(thing)
         thing.dup
       rescue TypeError
@@ -101,6 +118,9 @@ class Chef
       # `merge_onto` is the object that will "lose" in case of conflict.
       # `merge_with` is the object whose values will replace `merge_onto`s
       # values when there is a conflict.
+      #
+      # @api private
+      #
       def hash_only_merge!(merge_onto, merge_with)
         # If there are two Hashes, recursively merge.
         if merge_onto.is_a?(Hash) && merge_with.is_a?(Hash)
@@ -120,17 +140,14 @@ class Chef
             end
           end
           merge_onto
-
-        # If merge_with is nil, don't replace merge_onto
-        elsif merge_with.nil?
-          merge_onto
-
         # In all other cases, replace merge_onto with merge_with
         else
           merge_with
         end
       end
 
+      # @api private
+      #
       def deep_merge(source, dest)
         deep_merge!(safe_dup(source), safe_dup(dest))
       end

data/{spec/unit/monkey_patches/uri_spec.rb → lib/chef/mixin/default_paths.rb}

@@ -1,5 +1,4 @@
-#--
-# Author:: Daniel DeLeo (<dan@chef.io>)
+#
 # Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
@@ -16,19 +15,18 @@
 # limitations under the License.
 #
 
-require "spec_helper"
-describe URI do
-
-  describe "when a URI contains an IPv6 literal" do
+require "chef-utils/dsl/default_paths" unless defined?(ChefUtils::DSL::DefaultPaths)
 
-    let(:ipv6_uri) do
-      URI.parse("https://[2a00:1450:4009:809::1008]:8443")
-    end
+class Chef
+  module Mixin
+    module DefaultPaths
+      include ChefUtils::DSL::DefaultPaths
 
-    it "returns the hostname without brackets" do
-      expect(ipv6_uri.hostname).to eq("2a00:1450:4009:809::1008")
+      def enforce_default_paths(env = ENV)
+        if Chef::Config[:enforce_default_paths] || Chef::Config[:enforce_path_sanity]
+          env["PATH"] = default_paths(env)
+        end
+      end
     end
-
   end
-
 end

data/lib/chef/mixin/openssl_helper.rb

@@ -14,15 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+autoload :OpenSSL, "openssl"
 
 class Chef
   module Mixin
     # various helpers for use with openssl. Currently used by the openssl_* resources
     module OpenSSLHelper
-      def self.included(_base)
-        require "openssl" unless defined?(::OpenSSL)
-      end
-
       # determine the key filename from the cert filename
       # @param [String] cert_filename the path to the certfile
       # @return [String] the path to the keyfile
@@ -158,7 +155,7 @@ class Chef
       # @return [OpenSSL::PKey::DH]
       def gen_ec_priv_key(curve)
         raise TypeError, "curve must be a string" unless curve.is_a?(String)
-        raise ArgumentError, "Specified curve is not available on this system" unless curve == "prime256v1" || curve == "secp384r1" || curve == "secp521r1"
+        raise ArgumentError, "Specified curve is not available on this system" unless %w{prime256v1 secp384r1 secp521r1}.include?(curve)
 
         ::OpenSSL::PKey::EC.new(curve).generate_key
       end
@@ -282,7 +279,9 @@ class Chef
           ef.issuer_certificate = info["issuer"]
         end
         ef.subject_certificate = cert
-        ef.config = ::OpenSSL::Config.load(::OpenSSL::Config::DEFAULT_CONFIG_FILE)
+        if openssl_config = __openssl_config
+          ef.config = openssl_config
+        end
 
         cert.extensions = extension
         cert.add_extension ef.create_extension("subjectKeyIdentifier", "hash")
@@ -313,7 +312,9 @@ class Chef
         crl.last_update = Time.now
         crl.next_update = Time.now + 3600 * 24 * info["validity"]
 
-        ef.config = ::OpenSSL::Config.load(::OpenSSL::Config::DEFAULT_CONFIG_FILE)
+        if openssl_config = __openssl_config
+          ef.config = openssl_config
+        end
         ef.issuer_certificate = info["issuer"]
 
         crl.add_extension ::OpenSSL::X509::Extension.new("crlNumber", ::OpenSSL::ASN1::Integer(1))
@@ -369,8 +370,7 @@ class Chef
         revoked.add_extension(ext)
         crl.add_revoked(revoked)
 
-        crl = renew_x509_crl(crl, ca_private_key, info)
-        crl
+        renew_x509_crl(crl, ca_private_key, info)
       end
 
       # renew a X509 crl given
@@ -391,7 +391,9 @@ class Chef
         crl.next_update = crl.last_update + 3600 * 24 * info["validity"]
 
         ef = ::OpenSSL::X509::ExtensionFactory.new
-        ef.config = ::OpenSSL::Config.load(::OpenSSL::Config::DEFAULT_CONFIG_FILE)
+        if openssl_config = __openssl_config
+          ef.config = openssl_config
+        end
         ef.issuer_certificate = info["issuer"]
 
         crl.extensions = [ ::OpenSSL::X509::Extension.new("crlNumber",
@@ -407,7 +409,7 @@ class Chef
       # @param [string] cert_file path of the cert file or cert content
       # @param [integer] renew_before_expiry number of days before expiration
       # @return [true, false]
-      def cert_need_renewall?(cert_file, renew_before_expiry)
+      def cert_need_renewal?(cert_file, renew_before_expiry)
         resp = true
         cert_content = ::File.exist?(cert_file) ? File.read(cert_file) : cert_file
         begin
@@ -422,6 +424,25 @@ class Chef
 
         resp
       end
+
+      alias_method :cert_need_renewall?, :cert_need_renewal?
+
+      private
+
+      def __openssl_config
+        path = if File.exist?(::OpenSSL::Config::DEFAULT_CONFIG_FILE)
+                 OpenSSL::Config::DEFAULT_CONFIG_FILE
+               else
+                 Dir[File.join(RbConfig::CONFIG["prefix"], "**", "openssl.cnf")].first
+               end
+
+        if File.exist?(path)
+          ::OpenSSL::Config.load(path)
+        else
+          Chef::Log.warn("Couldn't find OpenSSL config file")
+          nil
+        end
+      end
     end
   end
 end

data/lib/chef/mixin/path_sanity.rb

@@ -16,14 +16,15 @@
 # limitations under the License.
 #
 
+require_relative "default_paths"
+
 class Chef
   module Mixin
-    # @ deprecated
     module PathSanity
+      include Chef::Mixin::DefaultPaths
+
       def enforce_path_sanity(env = ENV)
-        if Chef::Config[:enforce_path_sanity]
-          env["PATH"] = ChefUtils::DSL::PathSanity.sanitized_path(env)
-        end
+        enforce_default_paths(env)
       end
     end
   end

data/lib/chef/mixin/powershell_exec.rb

@@ -15,15 +15,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative "../powershell"
+# Powershell is being run using chef-powershell gem. The code resides at https://github.com/chef/chef-powershell-shim
 
-# The powershell_exec mixin provides in-process access to PowerShell engine via
-# a COM interop (installed by the Chef Client installer).
+# The powershell_exec mixin provides in-process access to the PowerShell engine.
 #
-# powershell_exec returns a Chef::PowerShell object that provides 4 methods:
+# powershell_exec is initialized with a string that should be set to the script
+# to run and also takes an optional interpreter argument which must be either
+# :powershell (Windows PowerShell which is the default) or :pwsh (PowerShell
+# Core). It will return a Chef::PowerShell object that provides 5 methods:
 #
 # .result - returns a hash representing the results returned by executing the
 #           PowerShell script block
+# .verbose - this is an array of string containing any messages written to the
+#           PowerShell verbose stream during execution
 # .errors - this is an array of string containing any messages written to the
 #           PowerShell error stream during execution
 # .error? - returns true if there were error messages written to the PowerShell
@@ -42,6 +46,9 @@ require_relative "../powershell"
 # > powershell_exec("$a = $true; $a").result
 #  => true
 #
+# > powershell_exec("$PSVersionTable", :pwsh).result["PSEdition"]
+#  => "Core"
+#
 # > powershell_exec("not-found").errors
 #  => ["ObjectNotFound: (not-found:String) [], CommandNotFoundException: The
 #  term 'not-found' is not recognized as the name of a cmdlet, function, script
@@ -87,27 +94,15 @@ require_relative "../powershell"
 #   credentials of the user running Chef Client are used.
 #
 
+if ChefUtils.windows?
+  require "chef-powershell"
+end
+
 class Chef
   module Mixin
     module PowershellExec
-      # Run a command under PowerShell via a managed (.NET) COM interop API.
-      # This implementation requires the managed dll to be registered on the
-      # target machine.
-      #
-      # Requires: .NET Framework 4.0 or higher on the target machine.
-      #
-      # @param script [String] script to run
-      # @return [Chef::PowerShell] output
-      def powershell_exec(script)
-        Chef::PowerShell.new(script)
-      end
-
-      # The same as the #powershell_exec method except this will raise
-      # Chef::PowerShell::CommandFailed if the command fails
-      def powershell_exec!(script)
-        cmd = Chef::PowerShell.new(script)
-        cmd.error!
-        cmd
+      if ChefUtils.windows?
+        include ChefPowerShell::ChefPowerShellModule::PowerShellExec
       end
     end
   end

data/lib/chef/mixin/powershell_out.rb

@@ -28,19 +28,24 @@ class Chef
       # can be set to :i386 or :x86_64 to force the windows architecture.
       #
       # @param script [String] script to run
+      # @param interpreter [Symbol] the interpreter type, `:powershell` or `:pwsh`
       # @param options [Hash] options hash
       # @return [Mixlib::Shellout] mixlib-shellout object
       def powershell_out(*command_args)
         script = command_args.first
         options = command_args.last.is_a?(Hash) ? command_args.last : nil
+        interpreter = command_args[1].is_a?(Symbol) ? command_args[1] : :powershell
 
-        run_command_with_os_architecture(script, options)
+        raise ArgumentError, "Expected interpreter of :powershell or :pwsh" unless %i{powershell pwsh}.include?(interpreter)
+
+        run_command_with_os_architecture(script, interpreter, options)
       end
 
       # Run a command under powershell with the same API as shell_out!
       # (raises exceptions on errors)
       #
       # @param script [String] script to run
+      # @param interpreter [Symbol] the interpreter type, `:powershell` or `:pwsh`
       # @param options [Hash] options hash
       # @return [Mixlib::Shellout] mixlib-shellout object
       def powershell_out!(*command_args)
@@ -56,16 +61,17 @@ class Chef
       # because chef-client runs as a 32-bit app on 64-bit windows).
       #
       # @param script [String] script to run
+      # @param interpreter [Symbol] the interpreter type, `:powershell` or `:pwsh`
       # @param options [Hash] options hash
       # @return [Mixlib::Shellout] mixlib-shellout object
-      def run_command_with_os_architecture(script, options)
+      def run_command_with_os_architecture(script, interpreter, options)
         options ||= {}
         options = options.dup
         arch = options.delete(:architecture)
 
         with_os_architecture(nil, architecture: arch) do
           shell_out(
-            build_powershell_command(script),
+            build_powershell_command(script, interpreter),
             **options
           )
         end
@@ -74,8 +80,9 @@ class Chef
       # Helper to build a powershell command around the script to run.
       #
       # @param script [String] script to run
+      # @param interpreter [Symbol] the interpreter type, `:powershell` or `:pwsh`
       # @return [String] powershell command to execute
-      def build_powershell_command(script)
+      def build_powershell_command(script, interpreter)
         flags = [
           # Hides the copyright banner at startup.
           "-NoLogo",
@@ -91,7 +98,7 @@ class Chef
           "-InputFormat None",
         ]
 
-        "powershell.exe #{flags.join(" ")} -Command \"#{script.gsub('"', '\"')}\""
+        "#{interpreter}.exe #{flags.join(" ")} -Command \"#{script.gsub('"', '\"')}\""
       end
     end
   end

data/lib/chef/mixin/properties.rb

@@ -135,6 +135,8 @@ class Chef
           property.emit_dsl
         end
 
+        alias :attribute :property
+
         #
         # Create a reusable property type that can be used in multiple properties
         # in different resources.

data/lib/chef/mixin/securable.rb

@@ -172,14 +172,14 @@ class Chef
         end
       end
 
-      if RUBY_PLATFORM =~ /mswin|mingw|windows/
+      if RUBY_PLATFORM.match?(/mswin|mingw|windows/)
         include WindowsSecurableAttributes
       end
 
       # Callback that fires when included; will extend the including class
       # with WindowsMacros and define #rights and #deny_rights on it.
       def self.included(including_class)
-        if RUBY_PLATFORM =~ /mswin|mingw|windows/
+        if RUBY_PLATFORM.match?(/mswin|mingw|windows/)
           including_class.extend(WindowsMacros)
           # create a default 'rights' attribute
           including_class.rights_attribute(:rights)

data/lib/chef/mixin/shell_out.rb

@@ -15,198 +15,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "mixlib/shellout" unless defined?(Mixlib::ShellOut::DEFAULT_READ_TIMEOUT)
-require "chef-utils/dsl/path_sanity" unless defined?(ChefUtils::DSL::PathSanity)
+require "mixlib/shellout/helper" unless defined?(Mixlib::ShellOut::Helper)
+require_relative "chef_utils_wiring" unless defined?(Chef::Mixin::ChefUtilsWiring)
 
 class Chef
   module Mixin
     module ShellOut
-
-      # PREFERRED APIS:
-      #
-      # all consumers should now call shell_out!/shell_out.
-      #
-      # the shell_out_compacted/shell_out_compacted! APIs are private but are intended for use
-      # in rspec tests, and should ideally always be used to make code refactoring that do not
-      # change behavior easier:
-      #
-      # allow(provider).to receive(:shell_out_compacted!).with("foo", "bar", "baz")
-      # provider.shell_out!("foo", [ "bar", nil, "baz"])
-      # provider.shell_out!(["foo", nil, "bar" ], ["baz"])
-      #
-      # note that shell_out_compacted also includes adding the magical timeout option to force
-      # people to setup expectations on that value explicitly.  it does not include the default_env
-      # mangling in order to avoid users having to setup an expectation on anything other than
-      # setting `default_env: false` and allow us to make tweak to the default_env without breaking
-      # a thousand unit tests.
-      #
-
-      def shell_out(*args, **options)
-        options = options.dup
-        options = Chef::Mixin::ShellOut.maybe_add_timeout(self, options)
-        if options.empty?
-          shell_out_compacted(*Chef::Mixin::ShellOut.clean_array(*args))
-        else
-          shell_out_compacted(*Chef::Mixin::ShellOut.clean_array(*args), **options)
-        end
-      end
-
-      def shell_out!(*args, **options)
-        options = options.dup
-        options = Chef::Mixin::ShellOut.maybe_add_timeout(self, options)
-        if options.empty?
-          shell_out_compacted!(*Chef::Mixin::ShellOut.clean_array(*args))
-        else
-          shell_out_compacted!(*Chef::Mixin::ShellOut.clean_array(*args), **options)
-        end
-      end
-
-      # helper sugar for resources that support passing timeouts to shell_out
-      #
-      # module method to not pollute namespaces, but that means we need self injected as an arg
-      # @api private
-      def self.maybe_add_timeout(obj, options)
-        options = options.dup
-        # historically resources have not properly declared defaults on their timeouts, so a default default of 900s was enforced here
-        default_val = 900
-        return options if options.key?(:timeout)
-
-        # FIXME: need to nuke descendent tracker out of Chef::Provider so we can just define that class here without requiring the
-        # world, and then just use symbol lookup
-        if obj.class.ancestors.map(&:name).include?("Chef::Provider") && obj.respond_to?(:new_resource) && obj.new_resource.respond_to?(:timeout) && !options.key?(:timeout)
-          options[:timeout] = obj.new_resource.timeout ? obj.new_resource.timeout.to_f : default_val
-        end
-        options
-      end
-
-      # helper function to mangle options when `default_env` is true
-      #
-      # @api private
-      def self.apply_default_env(options)
-        options = options.dup
-        default_env = options.delete(:default_env)
-        default_env = true if default_env.nil?
-        if default_env
-          env_key = options.key?(:env) ? :env : :environment
-          options[env_key] = {
-            "LC_ALL" => Chef::Config[:internal_locale],
-            "LANGUAGE" => Chef::Config[:internal_locale],
-            "LANG" => Chef::Config[:internal_locale],
-            env_path => ChefUtils::DSL::PathSanity.sanitized_path,
-          }.update(options[env_key] || {})
-        end
-        options
-      end
-
-      private
-
-      # this SHOULD be used for setting up expectations in rspec, see banner comment at top.
-      #
-      # the private constraint is meant to avoid code calling this directly, rspec expectations are fine.
-      #
-      def shell_out_compacted(*args, **options)
-        options = Chef::Mixin::ShellOut.apply_default_env(options)
-        if options.empty?
-          Chef::Mixin::ShellOut.shell_out_command(*args)
-        else
-          Chef::Mixin::ShellOut.shell_out_command(*args, **options)
-        end
-      end
-
-      # this SHOULD be used for setting up expectations in rspec, see banner comment at top.
-      #
-      # the private constraint is meant to avoid code calling this directly, rspec expectations are fine.
-      #
-      def shell_out_compacted!(*args, **options)
-        options = Chef::Mixin::ShellOut.apply_default_env(options)
-        cmd = if options.empty?
-                Chef::Mixin::ShellOut.shell_out_command(*args)
-              else
-                Chef::Mixin::ShellOut.shell_out_command(*args, **options)
-              end
-        cmd.error!
-        cmd
-      end
-
-      # Helper for subclasses to reject nil out of an array.  It allows
-      # using the array form of shell_out (which avoids the need to surround arguments with
-      # quote marks to deal with shells).
-      #
-      # Usage:
-      #   shell_out!(*clean_array("useradd", universal_options, useradd_options, new_resource.username))
-      #
-      # universal_options and useradd_options can be nil, empty array, empty string, strings or arrays
-      # and the result makes sense.
-      #
-      # keeping this separate from shell_out!() makes it a bit easier to write expectations against the
-      # shell_out args and be able to omit nils and such in the tests (and to test that the nils are
-      # being rejected correctly).
-      #
-      # @param args [String] variable number of string arguments
-      # @return [Array] array of strings with nil and null string rejection
-
-      def self.clean_array(*args)
-        args.flatten.compact.map(&:to_s)
-      end
-
-      def self.transport_connection
-        Chef.run_context.transport_connection
-      end
-
-      def self.shell_out_command(*args, **options)
-        if Chef::Config.target_mode?
-          FakeShellOut.new(args, options, transport_connection.run_command(args.join(" "))) # FIXME: train should accept run_command(*args)
-        else
-          cmd = if options.empty?
-                  Mixlib::ShellOut.new(*args)
-                else
-                  Mixlib::ShellOut.new(*args, **options)
-                end
-          cmd.live_stream ||= io_for_live_stream
-          cmd.run_command
-          cmd
-        end
-      end
-
-      def self.io_for_live_stream
-        if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.debug?
-          STDOUT
-        else
-          nil
-        end
-      end
-
-      def self.env_path
-        if ChefUtils.windows?
-          "Path"
-        else
-          "PATH"
-        end
-      end
-
-      class FakeShellOut
-        attr_reader :stdout, :stderr, :exitstatus, :status
-
-        def initialize(args, options, result)
-          @args = args
-          @options = options
-          @stdout = result.stdout
-          @stderr = result.stderr
-          @exitstatus = result.exit_status
-          @status = OpenStruct.new(success?: ( exitstatus == 0 ))
-        end
-
-        def error?
-          exitstatus != 0
-        end
-
-        def error!
-          raise Mixlib::ShellOut::ShellCommandFailed, "Unexpected exit status of #{exitstatus} running #{@args}" if error?
-        end
-      end
+      include Mixlib::ShellOut::Helper
+      include Chef::Mixin::ChefUtilsWiring
     end
   end
 end
-
-# Break circular dep
-require_relative "../config"

data/lib/chef/mixin/template.rb

@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require "tempfile" unless defined?(Tempfile)
-require "erubis" unless defined?(Erubis)
+autoload :Tempfile, "tempfile"
+autoload :Erubis, "erubis"
 
 class Chef
   module Mixin
@@ -204,7 +204,7 @@ class Chef
           all_ivars.delete(:@_extension_modules)
           all_ivars.inject({}) do |ivar_map, ivar_symbol_name|
             value = instance_variable_get(ivar_symbol_name)
-            name_without_at = ivar_symbol_name.to_s[1..-1].to_sym
+            name_without_at = ivar_symbol_name.to_s[1..].to_sym
             ivar_map[name_without_at] = value
             ivar_map
           end
@@ -213,6 +213,7 @@ class Chef
 
       class TemplateError < RuntimeError
         attr_reader :original_exception, :context, :options
+
         SOURCE_CONTEXT_WINDOW = 2
 
         def initialize(original_exception, template, context, options)

data/lib/chef/mixin/unformatter.rb

@@ -21,7 +21,7 @@ class Chef
     module Unformatter
 
       def write(message)
-        data = message.match(/(\[.+?\] )?([\w]+):(.*)$/)
+        data = message.match(/(\[.+?\] )?(\w+):(.*)$/)
         send(data[2].downcase.chomp.to_sym, data[3].strip)
       rescue NoMethodError
         send(:info, message)