chef 12.18.31 → 13.0.118

data/lib/chef/mixin/get_source_from_package.rb

@@ -37,9 +37,9 @@ class Chef
         return if new_resource.package_name.is_a?(Array)
         # if we're passed something that looks like a filesystem path, with no source, use it
         #  - require at least one '/' in the path to avoid gem_package "foo" breaking if a file named 'foo' exists in the cwd
-        if new_resource.source.nil? && new_resource.package_name.match(/#{::File::SEPARATOR}/) && ::File.exists?(new_resource.package_name)
+        if new_resource.source.nil? && new_resource.package_name.match(/#{::File::SEPARATOR}/) && ::File.exist?(new_resource.package_name)
           Chef::Log.debug("No package source specified, but #{new_resource.package_name} exists on the filesystem, copying to package source")
-          new_resource.source(@new_resource.package_name)
+          new_resource.source(new_resource.package_name)
         end
       end
     end

data/lib/chef/mixin/notifying_block.rb

@@ -20,15 +20,13 @@ class Chef
     module NotifyingBlock
 
       def notifying_block(&block)
-        begin
-          subcontext = subcontext_block(&block)
-          Chef::Runner.new(subcontext).converge
-        ensure
-          # recipes don't have a new_resource
-          if respond_to?(:new_resource)
-            if subcontext && subcontext.resource_collection.any?(&:updated?)
-              new_resource.updated_by_last_action(true)
-            end
+        subcontext = subcontext_block(&block)
+        Chef::Runner.new(subcontext).converge
+      ensure
+        # recipes don't have a new_resource
+        if respond_to?(:new_resource)
+          if subcontext && subcontext.resource_collection.any?(&:updated?)
+            new_resource.updated_by_last_action(true)
           end
         end
       end

data/lib/chef/mixin/params_validate.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,6 +18,7 @@
 require "chef/constants"
 require "chef/property"
 require "chef/delayed_evaluator"
+require "chef/exceptions"
 
 class Chef
   module Mixin
@@ -102,8 +103,8 @@ class Chef
           when Hash
             validation.each do |check, carg|
               check_method = "_pv_#{check}"
-              if self.respond_to?(check_method, true)
-                self.send(check_method, opts, key, carg)
+              if respond_to?(check_method, true)
+                send(check_method, opts, key, carg)
               else
                 raise ArgumentError, "Validation map has unknown check: #{check}"
               end
@@ -332,8 +333,8 @@ class Chef
       def _pv_name_property(opts, key, is_name_property = true)
         if is_name_property
           if opts[key].nil?
-            raise CannotValidateStaticallyError, "name_property cannot be evaluated without a resource." if self == Chef::Mixin::ParamsValidate
-            opts[key] = self.instance_variable_get(:"@name")
+            raise Exceptions::CannotValidateStaticallyError, "name_property cannot be evaluated without a resource." if self == Chef::Mixin::ParamsValidate
+            opts[key] = instance_variable_get(:"@name")
           end
         end
       end
@@ -404,7 +405,7 @@ class Chef
         passed = to_be.any? do |tb|
           case tb
           when Proc
-            raise CannotValidateStaticallyError, "is: proc { } must be evaluated once for each resource" if self == Chef::Mixin::ParamsValidate
+            raise Exceptions::CannotValidateStaticallyError, "is: proc { } must be evaluated once for each resource" if self == Chef::Mixin::ParamsValidate
             instance_exec(value, &tb)
           when Property
             begin
@@ -448,10 +449,10 @@ class Chef
       #
       def _pv_coerce(opts, key, coercer)
         if opts.has_key?(key.to_s)
-          raise CannotValidateStaticallyError, "coerce must be evaluated for each resource." if self == Chef::Mixin::ParamsValidate
+          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)
-          raise CannotValidateStaticallyError, "coerce must be evaluated for each resource." if self == Chef::Mixin::ParamsValidate
+          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
       end

data/lib/chef/mixin/path_sanity.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright 2011-2016, Chef Software Inc.
+# Copyright:: Copyright 2011-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,25 +22,23 @@ class Chef
 
       def enforce_path_sanity(env = ENV)
         if Chef::Config[:enforce_path_sanity]
-          env["PATH"] = "" if env["PATH"].nil?
-          path_separator = Chef::Platform.windows? ? ";" : ":"
-          existing_paths = env["PATH"].split(path_separator)
-          # ensure the Ruby and Gem bindirs are included
-          # mainly for 'full-stack' Chef installs
-          paths_to_add = []
-          paths_to_add << ruby_bindir unless sane_paths.include?(ruby_bindir)
-          paths_to_add << gem_bindir unless sane_paths.include?(gem_bindir)
-          paths_to_add << sane_paths if sane_paths
-          paths_to_add.flatten!.compact!
-          paths_to_add.each do |sane_path|
-            unless existing_paths.include?(sane_path)
-              env_path = env["PATH"].dup
-              env_path << path_separator unless env["PATH"].empty?
-              env_path << sane_path
-              env["PATH"] = env_path.encode("utf-8", invalid: :replace, undef: :replace)
-            end
-          end
+          env["PATH"] = sanitized_path(env)
+        end
+      end
+
+      def sanitized_path(env = ENV)
+        env_path = env["PATH"].nil? ? "" : env["PATH"].dup
+        path_separator = Chef::Platform.windows? ? ";" : ":"
+        # ensure the Ruby and Gem bindirs are included
+        # mainly for 'full-stack' Chef installs
+        new_paths = env_path.split(path_separator)
+        [ ruby_bindir, gem_bindir ].compact.each do |path|
+          new_paths = [ path ] + new_paths unless new_paths.include?(path)
+        end
+        sane_paths.each do |path|
+          new_paths << path unless new_paths.include?(path)
         end
+        new_paths.join(path_separator).encode("utf-8", invalid: :replace, undef: :replace)
       end
 
       private

data/lib/chef/mixin/securable.rb

@@ -110,7 +110,7 @@ class Chef
           # equivalent to something like:
           # def rights(permissions=nil, principals=nil, args_hash=nil)
           define_method(name) do |permissions = nil, principals = nil, args_hash = nil|
-            rights = self.instance_variable_get("@#{name}".to_sym)
+            rights = instance_variable_get("@#{name}".to_sym)
             unless permissions.nil?
               input = {
                 :permissions => permissions,

data/lib/chef/mixin/shell_out.rb

@@ -1,6 +1,6 @@
 #--
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2010-2016, Chef Software Inc.
+# Copyright:: Copyright 2010-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,10 +16,12 @@
 # limitations under the License.
 
 require "mixlib/shellout"
+require "chef/mixin/path_sanity"
 
 class Chef
   module Mixin
     module ShellOut
+      include Chef::Mixin::PathSanity
 
       # PREFERRED APIS:
       #
@@ -75,6 +77,24 @@ class Chef
         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)
+      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)
+      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
@@ -89,6 +109,7 @@ class Chef
           "LC_ALL" => Chef::Config[:internal_locale],
           "LANGUAGE" => Chef::Config[:internal_locale],
           "LANG" => Chef::Config[:internal_locale],
+          env_path => sanitized_path,
         }.update(options[env_key] || {})
         shell_out_command(*args, **options)
       end
@@ -110,28 +131,6 @@ class Chef
         cmd
       end
 
-      DEPRECATED_OPTIONS =
-        [ [:command_log_level,   :log_level],
-          [:command_log_prepend, :log_tag] ]
-
-      # CHEF-3090: Deprecate command_log_level and command_log_prepend
-      # Patterned after https://github.com/chef/chef/commit/e1509990b559984b43e428d4d801c394e970f432
-      def run_command_compatible_options(command_args)
-        return command_args unless command_args.last.is_a?(Hash)
-
-        my_command_args = command_args.dup
-        my_options = my_command_args.last
-
-        DEPRECATED_OPTIONS.each do |old_option, new_option|
-          # Edge case: someone specifies :command_log_level and 'command_log_level' in the option hash
-          next unless value = my_options.delete(old_option) || my_options.delete(old_option.to_s)
-          deprecate_option old_option, new_option
-          my_options[new_option] = value
-        end
-
-        return my_command_args
-      end
-
       # Helper for sublcasses 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.
@@ -139,7 +138,8 @@ class Chef
       # @param args [String] variable number of string arguments
       # @return [String] nicely concatenated string or empty string
       def a_to_s(*args)
-        # FIXME: this should be deprecated in favor of shell_out_compact/shell_out_compact!
+        # 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(" ")
       end
 
@@ -166,16 +166,12 @@ class Chef
       private
 
       def shell_out_command(*command_args)
-        cmd = Mixlib::ShellOut.new(*run_command_compatible_options(command_args))
+        cmd = Mixlib::ShellOut.new(*command_args)
         cmd.live_stream ||= io_for_live_stream
         cmd.run_command
         cmd
       end
 
-      def deprecate_option(old_option, new_option)
-        Chef.deprecated :internal_api, "Chef::Mixin::ShellOut option :#{old_option} is deprecated. Use :#{new_option}"
-      end
-
       def io_for_live_stream
         if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.debug?
           STDOUT
@@ -183,6 +179,14 @@ class Chef
           nil
         end
       end
+
+      def env_path
+        if Chef::Platform.windows?
+          "Path"
+        else
+          "PATH"
+        end
+      end
     end
   end
 end

data/lib/chef/mixin/unformatter.rb

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

data/lib/chef/mixin/uris.rb

@@ -31,12 +31,10 @@ class Chef
       end
 
       def as_uri(source)
-        begin
-          URI.parse(source)
-        rescue URI::InvalidURIError
-          Chef::Log.warn("#{source} was an invalid URI. Trying to escape invalid characters")
-          URI.parse(Addressable::URI.encode(source))
-        end
+        URI.parse(source)
+      rescue URI::InvalidURIError
+        Chef::Log.warn("#{source} was an invalid URI. Trying to escape invalid characters")
+        URI.parse(Addressable::URI.encode(source))
       end
 
     end

data/lib/chef/mixin/versioned_api.rb

@@ -0,0 +1,84 @@
+#--
+# Copyright:: Copyright 2017, 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
+  module Mixin
+    module VersionedAPI
+
+      def minimum_api_version(version = nil)
+        if version
+          @minimum_api_version = version
+        else
+          @minimum_api_version
+        end
+      end
+
+    end
+
+    module VersionedAPIFactory
+
+      def versioned_interfaces
+        @versioned_interfaces ||= []
+      end
+
+      def add_versioned_api_class(klass)
+        versioned_interfaces << klass
+      end
+
+      def versioned_api_class
+        get_class_for(:max_server_version)
+      end
+
+      def get_class_for(type)
+        versioned_interfaces.select do |klass|
+          version = klass.send(:minimum_api_version)
+          # min and max versions will be nil if we've not made a request to the server yet,
+          # in which case we'll just start with the highest version and see what happens
+          ServerAPIVersions.instance.min_server_version.nil? || (version >= ServerAPIVersions.instance.min_server_version && version <= ServerAPIVersions.instance.send(type))
+        end
+          .sort { |a, b| a.send(:minimum_api_version) <=> b.send(:minimum_api_version) }
+          .last
+      end
+
+      def def_versioned_delegator(method)
+        line_no = __LINE__; str = %{
+          def self.#{method}(*args, &block)
+            versioned_api_class.__send__(:#{method}, *args, &block)
+          end
+        }
+        module_eval(str, __FILE__, line_no)
+      end
+
+      # When teeing up an HTTP request, we need to be able to ask which API version we should use.
+      # Something in Net::HTTP seems to expect to strip headers, so we return this as a string.
+      def best_request_version
+        klass = get_class_for(:max_server_version)
+        klass.minimum_api_version.to_s
+      end
+
+      def possible_requests
+        versioned_interfaces.length
+      end
+
+      def new(*args)
+        object = versioned_api_class.allocate
+        object.send(:initialize, *args)
+        object
+      end
+    end
+  end
+end

data/lib/chef/mixin/which.rb

@@ -1,6 +1,6 @@
 #--
 # Author:: Lamont Granquist <lamont@chef.io>
-# Copyright:: Copyright 2010-2016, Chef Software Inc.
+# Copyright:: Copyright 2010-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,15 +18,32 @@
 class Chef
   module Mixin
     module Which
-      def which(cmd, extra_path: nil)
+      def which(*cmds, extra_path: nil, &block)
+        where(*cmds, extra_path: extra_path, &block).first || false
+      end
+
+      def where(*cmds, extra_path: nil, &block)
         # NOTE: unnecessarily duplicates function of path_sanity
         extra_path ||= [ "/bin", "/usr/bin", "/sbin", "/usr/sbin" ]
-        paths = ENV["PATH"].split(File::PATH_SEPARATOR) + extra_path
-        paths.each do |path|
-          filename = Chef.path_to(File.join(path, cmd))
-          return filename if File.executable?(filename)
-        end
-        false
+        paths = env_path.split(File::PATH_SEPARATOR) + extra_path
+        cmds.map do |cmd|
+          paths.map do |path|
+            filename = Chef.path_to(File.join(path, cmd))
+            filename if valid_executable?(filename, &block)
+          end.compact
+        end.flatten
+      end
+
+      private
+
+      # for test stubbing
+      def env_path
+        ENV["PATH"]
+      end
+
+      def valid_executable?(filename, &block)
+        return false unless File.executable?(filename) && !File.directory?(filename)
+        block ? yield(filename) : true
       end
     end
   end

data/lib/chef/mixin/windows_architecture_helper.rb

@@ -74,11 +74,11 @@ class Chef
 
       def node_supports_windows_architecture?(node, desired_architecture)
         assert_valid_windows_architecture!(desired_architecture)
-        return ( node_windows_architecture(node) == :x86_64 ) || ( desired_architecture == :i386 )
+        ( node_windows_architecture(node) == :x86_64 ) || ( desired_architecture == :i386 )
       end
 
       def valid_windows_architecture?(architecture)
-        return ( architecture == :x86_64 ) || ( architecture == :i386 )
+        ( architecture == :x86_64 ) || ( architecture == :i386 )
       end
 
       def assert_valid_windows_architecture!(architecture)

data/lib/chef/mixin/xml_escape.rb

@@ -103,11 +103,9 @@ class Chef
           (0xE000..0xFFFD), (0x10000..0x10FFFF)]
 
         def xml_escape(unescaped_str)
-          begin
-            unescaped_str.unpack("U*").map { |char| xml_escape_char!(char) }.join
-          rescue
-            unescaped_str.unpack("C*").map { |char| xml_escape_char!(char) }.join
-          end
+          unescaped_str.unpack("U*").map { |char| xml_escape_char!(char) }.join
+        rescue
+          unescaped_str.unpack("C*").map { |char| xml_escape_char!(char) }.join
         end
 
         private

data/lib/chef/mixins.rb

@@ -1,6 +1,5 @@
 require "chef/mixin/shell_out"
 require "chef/mixin/checksum"
-require "chef/mixin/command"
 require "chef/mixin/convert_to_class_name"
 require "chef/mixin/create_path"
 require "chef/mixin/deep_merge"

data/lib/chef/monkey_patches/webrick-utils.rb

@@ -44,7 +44,7 @@ module WEBrick
         end
       end
       raise last_error if sockets.empty?
-      return sockets
+      sockets
     end
     module_function :create_listeners
   end

data/lib/chef/node/attribute.rb

@@ -1,7 +1,7 @@
 #--
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: AJ Christensen (<aj@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -216,16 +216,12 @@ class Chef
        # that precedence level, +value+ will be the symbol +:not_present+.
       def debug_value(*args)
         COMPONENTS.map do |component|
-          ivar = instance_variable_get(component)
-          value = args.inject(ivar) do |so_far, key|
-            if so_far == :not_present
-              :not_present
-            elsif so_far.has_key?(key)
-              so_far[key]
-            else
+          value =
+            begin
+              instance_variable_get(component).read!(*args)
+            rescue
               :not_present
             end
-          end
           [component.to_s.sub(/^@/, ""), value]
         end
       end
@@ -454,19 +450,19 @@ class Chef
       end
 
       def write(level, *args, &block)
-        self.send(level).write(*args, &block)
+        send(level).write(*args, &block)
       end
 
       def write!(level, *args, &block)
-        self.send(level).write!(*args, &block)
+        send(level).write!(*args, &block)
       end
 
       def unlink(level, *path)
-        self.send(level).unlink(*path)
+        send(level).unlink(*path)
       end
 
       def unlink!(level, *path)
-        self.send(level).unlink!(*path)
+        send(level).unlink!(*path)
       end
 
       alias :attribute? :has_key?
@@ -476,25 +472,6 @@ class Chef
 
       alias :each_attribute :each
 
-      def method_missing(symbol, *args)
-        if symbol == :to_ary
-          merged_attributes.send(symbol, *args)
-        elsif args.empty?
-          Chef.deprecated(:attributes, %q{method access to node attributes (node.foo.bar) is deprecated and will be removed in Chef 13, please use bracket syntax (node["foo"]["bar"])})
-          if key?(symbol)
-            self[symbol]
-          else
-            raise NoMethodError, "Undefined method or attribute `#{symbol}' on `node'"
-          end
-        elsif symbol.to_s =~ /=$/
-          Chef.deprecated(:attributes, %q{method setting of node attributes (node.foo="bar") is deprecated and will be removed in Chef 13, please use bracket syntax (node["foo"]="bar")})
-          key_to_set = symbol.to_s[/^(.+)=$/, 1]
-          self[key_to_set] = (args.length == 1 ? args[0] : args)
-        else
-          raise NoMethodError, "Undefined node attribute or method `#{symbol}' on `node'"
-        end
-      end
-
       def to_s
         merged_attributes.to_s
       end

data/lib/chef/node/attribute_collections.rb

@@ -1,6 +1,6 @@
 #--
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2012-2016, Chef Software, Inc.
+# Copyright:: Copyright 2012-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -180,24 +180,6 @@ class Chef
 
       alias :attribute? :has_key?
 
-      def method_missing(symbol, *args)
-        # Calling `puts arg` implicitly calls #to_ary on `arg`. If `arg` does
-        # not implement #to_ary, ruby recognizes it as a single argument, and
-        # if it returns an Array, then ruby prints each element. If we don't
-        # account for that here, we'll auto-vivify a VividMash for the key
-        # :to_ary which creates an unwanted key and raises a TypeError.
-        if symbol == :to_ary
-          super
-        elsif args.empty?
-          self[symbol]
-        elsif symbol.to_s =~ /=$/
-          key_to_set = symbol.to_s[/^(.+)=$/, 1]
-          self[key_to_set] = (args.length == 1 ? args[0] : args)
-        else
-          raise NoMethodError, "Undefined node attribute or method `#{symbol}' on `node'. To set an attribute, use `#{symbol}=value' instead."
-        end
-      end
-
       def convert_key(key)
         super
       end

data/lib/chef/node/common_api.rb

@@ -24,7 +24,7 @@ class Chef
       # method-style access to attributes
 
       def valid_container?(obj, key)
-        return obj.is_a?(Hash) || (obj.is_a?(Array) && key.is_a?(Integer))
+        obj.is_a?(Hash) || (obj.is_a?(Array) && key.is_a?(Integer))
       end
 
       private :valid_container?
@@ -85,16 +85,14 @@ class Chef
             end
           end
         end
-        return true
+        true
       end
 
       # this is a safe non-autovivifying reader that returns nil if the attribute does not exist
       def read(*path)
-        begin
-          read!(*path)
-        rescue Chef::Exceptions::NoSuchAttribute
-          nil
-        end
+        read!(*path)
+      rescue Chef::Exceptions::NoSuchAttribute
+        nil
       end
 
       # non-autovivifying reader that throws an exception if the attribute does not exist