chef 14.2.0 → 14.3.37

data/lib/chef/log.rb

@@ -46,19 +46,21 @@ class Chef
     #
     def self.caller_location
       # Pick the first caller that is *not* part of the Chef gem, that's the
-      # thing the user wrote.
+      # thing the user wrote. Or failing that, the most recent caller.
       chef_gem_path = File.expand_path("../..", __FILE__)
-      caller(0..20).find { |c| !c.start_with?(chef_gem_path) }
+      caller(0..20).find { |c| !c.start_with?(chef_gem_path) } || caller(0..1)[0]
     end
 
-    def self.deprecation(msg = nil, location = caller(2..2)[0], &block)
-      if msg
-        msg << " at #{Array(location).join("\n")}"
-        msg = msg.join("") if msg.respond_to?(:join)
-      end
+    # Log a deprecation warning.
+    #
+    # If the treat_deprecation_warnings_as_errors config option is set, this
+    # will raise an exception instead.
+    #
+    # @param msg [String] Deprecation message to display.
+    def self.deprecation(msg, &block)
       if Chef::Config[:treat_deprecation_warnings_as_errors]
         error(msg, &block)
-        raise Chef::Exceptions::DeprecatedFeatureError.new(msg.inspect)
+        raise Chef::Exceptions::DeprecatedFeatureError.new(msg)
       else
         warn(msg, &block)
       end

data/lib/chef/log/winevt.rb

@@ -36,7 +36,7 @@ class Chef
       FATAL_EVENT_ID = 10104
 
       # Since we must install the event logger, this is not really configurable
-      SOURCE = "Chef"
+      SOURCE = "Chef".freeze
 
       include Chef::Mixin::Unformatter
 
@@ -51,46 +51,46 @@ class Chef
 
       def info(msg)
         @eventlog.report_event(
-          :event_type => ::Win32::EventLog::INFO_TYPE,
-          :source => SOURCE,
-          :event_id => INFO_EVENT_ID,
-          :data => [msg]
+          event_type: ::Win32::EventLog::INFO_TYPE,
+          source: SOURCE,
+          event_id: INFO_EVENT_ID,
+          data: [msg]
         )
       end
 
       def warn(msg)
         @eventlog.report_event(
-          :event_type => ::Win32::EventLog::WARN_TYPE,
-          :source => SOURCE,
-          :event_id => WARN_EVENT_ID,
-          :data => [msg]
+          event_type: ::Win32::EventLog::WARN_TYPE,
+          source: SOURCE,
+          event_id: WARN_EVENT_ID,
+          data: [msg]
         )
       end
 
       def debug(msg)
         @eventlog.report_event(
-          :event_type => ::Win32::EventLog::INFO_TYPE,
-          :source => SOURCE,
-          :event_id => DEBUG_EVENT_ID,
-          :data => [msg]
+          event_type: ::Win32::EventLog::INFO_TYPE,
+          source: SOURCE,
+          event_id: DEBUG_EVENT_ID,
+          data: [msg]
         )
       end
 
       def error(msg)
         @eventlog.report_event(
-          :event_type => ::Win32::EventLog::ERROR_TYPE,
-          :source => SOURCE,
-          :event_id => ERROR_EVENT_ID,
-          :data => [msg]
+          event_type: ::Win32::EventLog::ERROR_TYPE,
+          source: SOURCE,
+          event_id: ERROR_EVENT_ID,
+          data: [msg]
         )
       end
 
       def fatal(msg)
         @eventlog.report_event(
-          :event_type => ::Win32::EventLog::ERROR_TYPE,
-          :source => SOURCE,
-          :event_id => FATAL_EVENT_ID,
-          :data => [msg]
+          event_type: ::Win32::EventLog::ERROR_TYPE,
+          source: SOURCE,
+          event_id: FATAL_EVENT_ID,
+          data: [msg]
         )
       end
 

data/lib/chef/mixin/api_version_request_handling.rb

@@ -50,12 +50,12 @@ class Chef
       end
 
       def reregister_only_v0_supported_error_msg(max_version, min_version)
-        <<-EOH
-The reregister command only supports server API version 0.
-The server that received the request supports a min version of #{min_version} and a max version of #{max_version}.
-User keys are now managed via the key rotation commmands.
-Please refer to the documentation on how to manage your keys via the key rotation commands:
-https://docs.chef.io/server_security.html#key-rotation
+        <<~EOH
+          The reregister command only supports server API version 0.
+          The server that received the request supports a min version of #{min_version} and a max version of #{max_version}.
+          User keys are now managed via the key rotation commmands.
+          Please refer to the documentation on how to manage your keys via the key rotation commands:
+          https://docs.chef.io/server_security.html#key-rotation
 EOH
       end
 

data/lib/chef/mixin/deep_merge.rb

@@ -106,7 +106,7 @@ class Chef
         if merge_onto.kind_of?(Hash) && merge_with.kind_of?(Hash)
           merge_with.each do |key, merge_with_value|
             value =
-              if merge_onto.has_key?(key)
+              if merge_onto.key?(key)
                 hash_only_merge(merge_onto[key], merge_with_value)
               else
                 merge_with_value

data/lib/chef/mixin/deprecation.rb

@@ -33,7 +33,7 @@ class Chef
     #     Chef::Mixin::RecipeDefinitionDSLCore is deprecated, use Chef::DSL::Recipe instead.
     #   EOM
     def self.deprecate_constant(name, replacement, message)
-      deprecated_constants[name] = { :replacement => replacement, :message => message }
+      deprecated_constants[name] = { replacement: replacement, message: message }
     end
 
     # Const missing hook to look up deprecated constants defined with
@@ -54,7 +54,7 @@ class Chef
     module Deprecation
 
       class DeprecatedObjectProxyBase
-        KEEPERS = %w{__id__ __send__ instance_eval == equal? initialize object_id}
+        KEEPERS = %w{__id__ __send__ instance_eval == equal? initialize object_id}.freeze
         instance_methods.each { |method_name| undef_method(method_name) unless KEEPERS.include?(method_name.to_s) }
       end
 

data/lib/chef/mixin/params_validate.rb

@@ -106,7 +106,7 @@ class Chef
           when false
             true
           when Hash
-            @validation_message[key] = validation.delete(:validation_message) if validation.has_key?(:validation_message)
+            @validation_message[key] = validation.delete(:validation_message) if validation.key?(:validation_message)
             validation.each do |check, carg|
               check_method = "_pv_#{check}"
               if respond_to?(check_method, true)
@@ -132,14 +132,14 @@ class Chef
       private
 
       def _validation_message(key, default)
-        @validation_message.has_key?(key) ? @validation_message[key] : default
+        @validation_message.key?(key) ? @validation_message[key] : default
       end
 
       # Return the value of a parameter, or nil if it doesn't exist.
       def _pv_opts_lookup(opts, key)
-        if opts.has_key?(key.to_s)
+        if opts.key?(key.to_s)
           opts[key.to_s]
-        elsif opts.has_key?(key.to_sym)
+        elsif opts.key?(key.to_sym)
           opts[key.to_sym]
         else
           nil
@@ -149,8 +149,8 @@ class Chef
       # Raise an exception if the parameter is not found.
       def _pv_required(opts, key, is_required = true, explicitly_allows_nil = false)
         if is_required
-          return true if opts.has_key?(key.to_s) && (explicitly_allows_nil || !opts[key.to_s].nil?)
-          return true if opts.has_key?(key.to_sym) && (explicitly_allows_nil || !opts[key.to_sym].nil?)
+          return true if opts.key?(key.to_s) && (explicitly_allows_nil || !opts[key.to_s].nil?)
+          return true if opts.key?(key.to_sym) && (explicitly_allows_nil || !opts[key.to_sym].nil?)
           raise Exceptions::ValidationFailed, _validation_message(key, "Required argument #{key.inspect} is missing!")
         end
         true
@@ -404,7 +404,7 @@ class Chef
       #   ```
       #
       def _pv_is(opts, key, to_be)
-        return true if !opts.has_key?(key.to_s) && !opts.has_key?(key.to_sym)
+        return true if !opts.key?(key.to_s) && !opts.key?(key.to_sym)
         value = _pv_opts_lookup(opts, key)
         to_be = [ to_be ].flatten(1)
         errors = []
@@ -454,10 +454,10 @@ class Chef
       #   ```
       #
       def _pv_coerce(opts, key, coercer)
-        if opts.has_key?(key.to_s)
+        if opts.key?(key.to_s)
           raise Exceptions::CannotValidateStaticallyError, "coerce must be evaluated for each resource." if self == Chef::Mixin::ParamsValidate
           opts[key.to_s] = instance_exec(opts[key], &coercer)
-        elsif opts.has_key?(key.to_sym)
+        elsif opts.key?(key.to_sym)
           raise Exceptions::CannotValidateStaticallyError, "coerce must be evaluated for each resource." if self == Chef::Mixin::ParamsValidate
           opts[key.to_sym] = instance_exec(opts[key], &coercer)
         end

data/lib/chef/mixin/properties.rb

@@ -102,14 +102,14 @@ class Chef
 
           options = options.inject({}) { |memo, (key, value)| memo[key.to_sym] = value; memo }
 
-          options[:instance_variable_name] = :"@#{name}" if !options.has_key?(:instance_variable_name)
+          options[:instance_variable_name] = :"@#{name}" if !options.key?(:instance_variable_name)
           options[:name] = name
           options[:declared_in] = self
 
           if type == NOT_PASSED
             # If a type is not passed, the property derives from the
             # superclass property (if any)
-            if properties.has_key?(name)
+            if properties.key?(name)
               property = properties[name].derive(**options)
             else
               property = property_type(**options)

data/lib/chef/mixin/securable.rb

@@ -24,7 +24,7 @@ class Chef
         set_or_return(
           :owner,
           arg,
-          :regex => Chef::Config[:user_valid_regex]
+          regex: Chef::Config[:user_valid_regex]
         )
       end
 
@@ -34,7 +34,7 @@ class Chef
         set_or_return(
           :group,
           arg,
-          :regex => Chef::Config[:group_valid_regex]
+          regex: Chef::Config[:group_valid_regex]
         )
       end
 
@@ -42,7 +42,7 @@ class Chef
         set_or_return(
           :mode,
           arg,
-          :callbacks => {
+          callbacks: {
             "not in valid numeric range" => lambda do |m|
               if m.kind_of?(String)
                 m =~ /^0/ || m = "0#{m}"
@@ -110,16 +110,16 @@ class Chef
             rights = instance_variable_get("@#{name}".to_sym)
             unless permissions.nil?
               input = {
-                :permissions => permissions,
-                :principals => principals,
+                permissions: permissions,
+                principals: principals,
               }
               input.merge!(args_hash) unless args_hash.nil?
 
-              validations = { :permissions => { :required => true },
-                              :principals => { :required => true, :kind_of => [String, Array] },
-                              :applies_to_children => { :equal_to => [ true, false, :containers_only, :objects_only ] },
-                              :applies_to_self => { :kind_of => [ TrueClass, FalseClass ] },
-                              :one_level_deep => { :kind_of => [ TrueClass, FalseClass ] },
+              validations = { permissions: { required: true },
+                              principals: { required: true, kind_of: [String, Array] },
+                              applies_to_children: { equal_to: [ true, false, :containers_only, :objects_only ] },
+                              applies_to_self: { kind_of: [ TrueClass, FalseClass ] },
+                              one_level_deep: { kind_of: [ TrueClass, FalseClass ] },
                             }
               validate(input, validations)
 
@@ -167,7 +167,7 @@ class Chef
           set_or_return(
             :inherits,
             arg,
-            :kind_of => [ TrueClass, FalseClass ]
+            kind_of: [ TrueClass, FalseClass ]
           )
         end
       end

data/lib/chef/mixin/shell_out.rb

@@ -21,88 +21,138 @@ require "chef/mixin/path_sanity"
 class Chef
   module Mixin
     module ShellOut
-      include Chef::Mixin::PathSanity
+      extend Chef::Mixin::PathSanity
 
       # PREFERRED APIS:
       #
-      # shell_out_compact and shell_out_compact! flatten their array arguments and remove nils and pass
-      # the resultant array to shell_out.  this actually eliminates spaces-in-args bugs because this:
+      # all consumers should now call shell_out!/shell_out.
       #
-      # shell_out!("command #{arg}")
+      # on unix the shell_out API supports the clean_array() kind of syntax (below) so that
+      # array args are flat/compact/to_s'd.  on windows, array args aren't supported to its
+      # up to the caller to join(" ") on arrays of strings.
       #
-      # becomes two arguments if arg has spaces and requires quotations:
+      # 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 refactorings that do not
+      # change behavior easier:
       #
-      # shell_out!("command '#{arg}'")
+      # 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"])
       #
-      # using shell_out_compact! this becomes:
-      #
-      # shell_out_compact!("command", arg)
-      #
-      # and spaces in the arg just works and it does not become two arguments (and the shell quoting around
-      # the argument must actually be removed).
-      #
-      # there's also an implicit join between all the array elements, and nested arrays are flattened which
-      # means that odd where-do-i-put-the-spaces options handling just works, and instead of this:
-      #
-      #    opts = ""                     # needs to be empty string for when foo and bar are both missing
-      #    opts << " -foo" if needs_foo? # needs the leading space on both of these
-      #    opts << " -bar" if needs_bar?
-      #    shell_out!("cmd#{opts}")      # have to think way too hard about why there's no space here
-      #
-      # becomes:
-      #
-      #    opts = []
-      #    opts << "-foo" if needs_foo?
-      #    opts << "-bar" if needs_bar?
-      #    shell_out_compact!("cmd", opts)
-      #
-      # and opts can be an empty array or nil and it'll work out fine.
-      #
-      # generally its best to use shell_out_compact! in code and setup expectations on shell_out! in tests
+      # 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_compact(*args, **options)
+        Chef.deprecated(:shell_out, "shell_out_compact should be replaced by shell_out")
         if options.empty?
-          shell_out(*clean_array(*args))
+          shell_out(*args)
         else
-          shell_out(*clean_array(*args), **options)
+          shell_out(*args, **options)
         end
       end
 
       def shell_out_compact!(*args, **options)
+        Chef.deprecated(:shell_out, "shell_out_compact! should be replaced by shell_out!")
         if options.empty?
-          shell_out!(*clean_array(*args))
+          shell_out!(*args)
         else
-          shell_out!(*clean_array(*args), **options)
+          shell_out!(*args, **options)
         end
       end
 
-      # helper sugar for resources that support passing timeouts to shell_out
-
       def shell_out_compact_timeout(*args, **options)
-        raise "object is not a resource that supports timeouts" unless respond_to?(:new_resource) && new_resource.respond_to?(:timeout)
-        options_dup = options.dup
-        options_dup[:timeout] = new_resource.timeout if new_resource.timeout
-        options_dup[:timeout] = 900 unless options_dup.key?(:timeout)
-        shell_out_compact(*args, **options_dup)
+        Chef.deprecated(:shell_out, "shell_out_compact_timeout should be replaced by shell_out")
+        if options.empty?
+          shell_out(*args, argument_that_will_go_away_in_chef_15_so_do_not_use_it: true)
+        else
+          shell_out(*args, argument_that_will_go_away_in_chef_15_so_do_not_use_it: true, **options)
+        end
       end
 
       def shell_out_compact_timeout!(*args, **options)
-        raise "object is not a resource that supports timeouts" unless respond_to?(:new_resource) && new_resource.respond_to?(:timeout)
-        options_dup = options.dup
-        options_dup[:timeout] = new_resource.timeout if new_resource.timeout
-        options_dup[:timeout] = 900 unless options_dup.key?(:timeout)
-        shell_out_compact!(*args, **options_dup)
+        Chef.deprecated(:shell_out, "shell_out_compact_timeout! should be replaced by shell_out!")
+        if options.empty?
+          shell_out!(*args, argument_that_will_go_away_in_chef_15_so_do_not_use_it: true)
+        else
+          shell_out!(*args, argument_that_will_go_away_in_chef_15_so_do_not_use_it: true, **options)
+        end
       end
 
-      # shell_out! runs a command on the system and will raise an error if the command fails, which is what you want
-      # for debugging, shell_out and shell_out! both will display command output to the tty when the log level is debug
-      # Generally speaking, 'extend Chef::Mixin::ShellOut' in your recipes and include 'Chef::Mixin::ShellOut' in your LWRPs
-      # You can also call Mixlib::Shellout.new directly, but you lose all of the above functionality
+      def shell_out_with_systems_locale(*args, **options)
+        Chef.deprecated(:shell_out, "shell_out_with_systems_locale should be replaced by shell_out with the default_env option set to false")
+        if options.empty?
+          shell_out(*args, default_env: false)
+        else
+          shell_out(*args, default_env: false, **options)
+        end
+      end
+
+      def shell_out_with_systems_locale!(*args, **options)
+        Chef.deprecated(:shell_out, "shell_out_with_systems_locale! should be replaced by shell_out! with the default_env option set to false")
+        if options.empty?
+          shell_out!(*args, default_env: false)
+        else
+          shell_out!(*args, default_env: false, **options)
+        end
+      end
+
+      def a_to_s(*args)
+        Chef.deprecated(:shell_out, "a_to_s is deprecated use shell_out with splat-args")
+        args.flatten.reject { |i| i.nil? || i == "" }.map(&:to_s).join(" ")
+      end
 
-      # we use 'en_US.UTF-8' by default because we parse localized strings in English as an API and
-      # generally must support UTF-8 unicode.
       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
+        force = options.delete(:argument_that_will_go_away_in_chef_15_so_do_not_use_it) # remove in Chef-15
+        # historically resources have not properly declared defaults on their timeouts, so a default default of 900s was enforced here
+        default_val = 900
+        if !force
+          return options if options.key?(:timeout) # leave this line in Chef-15, delete the rest of the conditional
+        else
+          default_val = options[:timeout] if options.key?(:timeout) # delete in Chef-15
+        end
+        # note that we can't define an empty Chef::Resource::LWRPBase because that breaks descendants tracker, so we'd have to instead require the file here, which would pull in half
+        # of chef, so instead convert to using strings.  once descendants tracker is gone, we can just declare the empty classes instead and use `is_a?` against the symbols.
+        # (be nice if ruby supported strings in `is_a?` for looser coupling).
+        # FIXME: just use `if obj.respond_to?(:new_resource) && obj.new_resource.respond_to?(:timeout) && !options.key?(:timeout)` in Chef 15
+        if obj.respond_to?(:new_resource) && ( force || ( obj.class.ancestors.map(&:name).include?("Chef::Provider") && !obj.class.ancestors.map(&:name).include?("Chef::Resource::LWRPBase") && !obj.class.ancestors.map(&:name).include?("Chef::Resource::ActionClass") && 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?
@@ -115,34 +165,37 @@ class Chef
             env_path => sanitized_path,
           }.update(options[env_key] || {})
         end
-        shell_out_command(*args, **options)
+        options
       end
 
-      # call shell_out (using en_US.UTF-8) and raise errors
-      def shell_out!(*command_args)
-        cmd = shell_out(*command_args)
-        cmd.error!
-        cmd
-      end
-
-      def shell_out_with_systems_locale(*args, **options) # FIXME: deprecate
-        shell_out(*args, default_env: false, **options)
-      end
+      private
 
-      def shell_out_with_systems_locale!(*args, **options) # FIXME: deprecate
-        shell_out!(*args, default_env: false, **options)
+      # 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
 
-      # Helper for subclasses to convert an array of string args into a string.  It
-      # will compact nil or empty strings in the array and will join the array elements
-      # with spaces, without introducing any double spaces for nil/empty elements.
+      # this SHOULD be used for setting up expectations in rspec, see banner comment at top.
       #
-      # @param args [String] variable number of string arguments
-      # @return [String] nicely concatenated string or empty string
-      def a_to_s(*args)
-        # can't quite deprecate this yet
-        #Chef.deprecated(:package_misc, "a_to_s is deprecated use shell_out_compact or shell_out_compact_timeout instead")
-        args.flatten.reject { |i| i.nil? || i == "" }.map(&:to_s).join(" ")
+      # 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
@@ -161,20 +214,23 @@ class Chef
       #
       # @param args [String] variable number of string arguments
       # @return [Array] array of strings with nil and null string rejection
-      def clean_array(*args)
+
+      def self.clean_array(*args)
         args.flatten.compact.map(&:to_s)
       end
 
-      private
-
-      def shell_out_command(*command_args)
-        cmd = Mixlib::ShellOut.new(*command_args)
+      def self.shell_out_command(*args, **options)
+        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
 
-      def io_for_live_stream
+      def self.io_for_live_stream
         if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.debug?
           STDOUT
         else
@@ -182,7 +238,7 @@ class Chef
         end
       end
 
-      def env_path
+      def self.env_path
         if Chef::Platform.windows?
           "Path"
         else