chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/log.rb

@@ -18,6 +18,7 @@
 # limitations under the License.
 
 require 'logger'
+require 'chef/monologger'
 require 'mixlib/log'
 
 class Chef
@@ -25,8 +26,7 @@ class Chef
     extend Mixlib::Log
 
     # Force initialization of the primary log device (@logger)
-    init
-
+    init(MonoLogger.new(STDOUT))
 
     class Formatter
       def self.show_time=(*args)

data/lib/chef/mixin/checksum.rb

@@ -17,16 +17,16 @@
 #
 
 require 'digest/sha2'
-require 'chef/checksum_cache'
+require 'chef/digester'
 
 class Chef
   module Mixin
     module Checksum
 
       def checksum(file)
-        Chef::ChecksumCache.checksum_for_file(file)
+        Chef::Digester.checksum_for_file(file)
       end
-      
+
     end
   end
 end

data/lib/chef/mixin/deep_merge.rb

@@ -8,9 +8,9 @@
 # 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.
@@ -26,20 +26,25 @@ class Chef
     #   deep_merge is available under the MIT license from
     #   http://trac.misuse.org/science/wiki/DeepMerge
     module DeepMerge
-      extend self
 
-      def merge(first, second)
-        first  = Mash.new(first)  unless first.kind_of?(Mash)
-        second = Mash.new(second) unless second.kind_of?(Mash)
+      class InvalidSubtractiveMerge < ArgumentError; end
 
-        DeepMerge.deep_merge(second, first, {:preserve_unmergeables => false})
-      end
 
-      def horizontal_merge(first, second)
+      OLD_KNOCKOUT_PREFIX = "!merge:".freeze
+
+      # Regex to match the "knockout prefix" that was used to indicate
+      # subtractive merging in Chef 10.x and previous. Subtractive merging is
+      # removed as of Chef 11, but we detect attempted use of it and raise an
+      # error (see: raise_if_knockout_used!)
+      OLD_KNOCKOUT_MATCH = %r[!merge].freeze
+
+      extend self
+
+      def merge(first, second)
         first  = Mash.new(first)  unless first.kind_of?(Mash)
         second = Mash.new(second) unless second.kind_of?(Mash)
 
-        DeepMerge.deep_merge(second, first, {:preserve_unmergeables => false, :horizontal_precedence => true})
+        DeepMerge.deep_merge(second, first)
       end
 
       # Inherited roles use the knockout_prefix array subtraction functionality
@@ -48,7 +53,7 @@ class Chef
         first  = Mash.new(first)  unless first.kind_of?(Mash)
         second = Mash.new(second) unless second.kind_of?(Mash)
 
-        DeepMerge.deep_merge(second, first, {:preserve_unmergeables => false, :knockout_prefix => "!merge", :horizontal_precedence => true})
+        DeepMerge.deep_merge(second, first)
       end
 
       class InvalidParameter < StandardError; end
@@ -67,217 +72,96 @@ class Chef
       #   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)
-      #
-      # Options:
-      #   Options are specified in the last parameter passed, which should be in hash format:
-      #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '!merge'})
-      #   :preserve_unmergeables  DEFAULT: false
-      #      Set to true to skip any unmergeable elements from source
-      #   :knockout_prefix        DEFAULT: nil
-      #      Set to string value to signify prefix which deletes elements from existing element
-      #      A colon is appended when indicating a specific value, eg:
-      #      :knockout_prefix => "dontmerge", is referenced as "dontmerge:foobar" in an array
-      #   :sort_merged_arrays     DEFAULT: false
-      #      Set to true to sort all arrays that are merged together
-      #   :unpack_arrays          DEFAULT: nil
-      #      Set to string value to run "Array::join" then "String::split" against all arrays
-      #   :merge_debug            DEFAULT: false
-      #      Set to true to get console output of merge process for debugging
-      #
-      # Selected Options Details:
-      # :knockout_prefix => The purpose of this is to provide a way to remove elements
-      #   from existing Hash by specifying them in a special way in incoming hash
-      #    source = {:x => ['!merge:1', '2']}
-      #    dest   = {:x => ['1', '3']}
-      #    dest.ko_deep_merge!(source)
-      #    Results: {:x => ['2','3']}
-      #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
-      #   the entire element to be removed:
-      #    source = {:x => '!merge'}
-      #    dest   = {:x => [1,2,3]}
-      #    dest.ko_deep_merge!(source)
-      #    Results: {:x => ""}
-      # :unpack_arrays => The purpose of this is to permit compound elements to be passed
-      #   in as strings and to be converted into discrete array elements
-      #   irsource = {:x => ['1,2,3', '4']}
-      #   dest   = {:x => ['5','6','7,8']}
-      #   dest.deep_merge!(source, {:unpack_arrays => ','})
-      #   Results: {:x => ['1','2','3','4','5','6','7','8'}
-      #   Why: If receiving data from an HTML form, this makes it easy for a checkbox
-      #    to pass multiple values from within a single HTML element
-      #
-      # There are many tests for this library - and you can learn more about the features
-      # and usages of deep_merge! by just browsing the test examples
-      def deep_merge!(source, dest, options = {})
-        # turn on this line for stdout debugging text
-        merge_debug = options[:merge_debug] || false
-        overwrite_unmergeable = !options[:preserve_unmergeables]
-        knockout_prefix = options[:knockout_prefix] || nil
-        raise InvalidParameter, "knockout_prefix cannot be an empty string in deep_merge!" if knockout_prefix == ""
-        raise InvalidParameter, "overwrite_unmergeable must be true if knockout_prefix is specified in deep_merge!" if knockout_prefix && !overwrite_unmergeable
-        # if present: we will split and join arrays on this char before merging
-        array_split_char = options[:unpack_arrays] || false
-        # request that we sort together any arrays when they are merged
-        sort_merged_arrays = options[:sort_merged_arrays] || false
-        di = options[:debug_indent] || ''
-        # do nothing if source is nil
-        return dest if source.nil?
+      def deep_merge!(source, dest)
         # if dest doesn't exist, then simply copy source to it
-        if dest.nil? && overwrite_unmergeable
+        if dest.nil?
           dest = source; return dest
         end
 
-        puts "#{di}Source class: #{source.class.inspect} :: Dest class: #{dest.class.inspect}" if merge_debug
-        if source.kind_of?(Hash)
-          puts "#{di}Hashes: #{source.inspect} :: #{dest.inspect}" if merge_debug
+        raise_if_knockout_used!(source)
+        raise_if_knockout_used!(dest)
+        case source
+        when nil
+          dest
+        when Hash
           source.each do |src_key, src_value|
             if dest.kind_of?(Hash)
-              puts "#{di} looping: #{src_key.inspect} => #{src_value.inspect} :: #{dest.inspect}" if merge_debug
               if dest[src_key]
-                puts "#{di} ==>merging: #{src_key.inspect} => #{src_value.inspect} :: #{dest[src_key].inspect}" if merge_debug
-                dest[src_key] = deep_merge!(src_value, dest[src_key], options.merge(:debug_indent => di + '  '))
-              else # dest[src_key] doesn't exist so we want to create and overwrite it (but we do this via deep_merge!)
-                puts "#{di} ==>merging over: #{src_key.inspect} => #{src_value.inspect}" if merge_debug
-                # NOTE: We are doing this via deep_merge! because the
-                # src_value can still contain merge directives such as
-                # knockout_prefix.
-                # Historically we have been dup'ing the src_value here
-                # and merging src_value with src_value.dup. This logic
-                # is not applicable anymore because it results in
-                # duplicates when merging two array values with
-                # :horizontal_precedence = true.
-                if src_value.nil?
-                  # Nothing to compute with an extra deep_merge!
-                  dest[src_key] = src_value
-                else
-                  dest[src_key] = deep_merge!(src_value, { }, options.merge(:debug_indent => di + '  '))
-                end
-              end
-            else # dest isn't a hash, so we overwrite it completely (if permitted)
-              if overwrite_unmergeable
-                puts "#{di}  overwriting dest: #{src_key.inspect} => #{src_value.inspect} -over->  #{dest.inspect}" if merge_debug
-                dest = overwrite_unmergeables(source, dest, options)
+                dest[src_key] = deep_merge!(src_value, dest[src_key])
+              else # dest[src_key] doesn't exist so we take whatever source has
+                raise_if_knockout_used!(src_value)
+                dest[src_key] = src_value
               end
+            else # dest isn't a hash, so we overwrite it completely
+              dest = source
             end
           end
-        elsif source.kind_of?(Array)
-          puts "#{di}Arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
-          # if we are instructed, join/split any source arrays before processing
-          if array_split_char
-            puts "#{di} split/join on source: #{source.inspect}" if merge_debug
-            source = source.join(array_split_char).split(array_split_char)
-            if dest.kind_of?(Array)
-              dest = dest.join(array_split_char).split(array_split_char)
-            end
-          end
-          # if there's a naked knockout_prefix in source, that means we are to truncate dest
-          ko_variants = [ knockout_prefix, "#{knockout_prefix}:" ]
-          ko_variants.each do |ko|
-            if source.index(ko)
-              dest = clear_or_nil(dest); source.delete(ko)
-            end
-          end
+        when Array
           if dest.kind_of?(Array)
-            if knockout_prefix
-              print "#{di} knocking out: " if merge_debug
-              # remove knockout prefix items from both source and dest
-              source.delete_if do |ko_item|
-                retval = false
-                item = ko_item.respond_to?(:gsub) ? ko_item.gsub(%r{^#{knockout_prefix}:}, "") : ko_item
-                if item != ko_item
-                  print "#{ko_item} - " if merge_debug
-                  dest.delete(item)
-                  dest.delete(ko_item)
-                  retval = true
-                end
-                retval
-              end
-              puts if merge_debug
-            end
-            puts "#{di} merging arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
-            # Behavior of merging arrays has changed with CHEF-4631.
-            # Old behavior was to deduplicate and merge the
-            # arrays. New behavior is to concatanate the arrays if the
-            # merge is happening on the same attribute precedence
-            # level and pick the value from the higher precedence
-            # level if merge is being done across the precedence
-            # levels.
-            # Old behavior can still be used by setting
-            # :deep_merge_array_concat to false in config.
-            if Chef::Config[:deep_merge_array_concat]
-              # If :horizontal_precedence is set, this means we are
-              # merging two arrays at the same precendence level so
-              # concatanate them. Otherwise this is a merge across
-              # precedence levels which means we will pick the one
-              # from higher precedence level.
-              if options[:horizontal_precedence]
-                dest += source
-              else
-                dest = source
-              end
-            else
-              # Pre CHEF-4631 behavior for array merging
-              dest = dest | source
-            end
-            dest.sort! if sort_merged_arrays
-          elsif overwrite_unmergeable
-            puts "#{di} overwriting dest: #{source.inspect} -over-> #{dest.inspect}" if merge_debug
-            dest = overwrite_unmergeables(source, dest, options)
+            dest = dest | source
+          else
+            dest = source
           end
+        when String
+          dest = source
         else # src_hash is not an array or hash, so we'll have to overwrite dest
-          puts "#{di}Others: #{source.inspect} :: #{dest.inspect}" if merge_debug
-          dest = overwrite_unmergeables(source, dest, options)
+          dest = source
         end
-        puts "#{di}Returning #{dest.inspect}" if merge_debug
         dest
       end # deep_merge!
 
-      # allows deep_merge! to uniformly handle overwriting of unmergeable entities
-      def overwrite_unmergeables(source, dest, options)
-        merge_debug = options[:merge_debug] || false
-        overwrite_unmergeable = !options[:preserve_unmergeables]
-        knockout_prefix = options[:knockout_prefix] || false
-        di = options[:debug_indent] || ''
-        if knockout_prefix && overwrite_unmergeable
-          if source.kind_of?(String) # remove knockout string from source before overwriting dest
-            if source == knockout_prefix
-              src_tmp = ""
-            else
-              src_tmp = source.gsub(%r{^#{knockout_prefix}:},"")
-            end
-          elsif source.kind_of?(Array) # remove all knockout elements before overwriting dest
-            src_tmp = source.delete_if {|ko_item| ko_item.kind_of?(String) && ko_item.match(%r{^#{knockout_prefix}:}) }
-          else
-            src_tmp = source
-          end
-          if src_tmp == source # if we didn't find a knockout_prefix then we just overwrite dest
-            puts "#{di}#{src_tmp.inspect} -over-> #{dest.inspect}" if merge_debug
-            dest = src_tmp
-          else # if we do find a knockout_prefix, then we just delete dest
-            puts "#{di}\"\" -over-> #{dest.inspect}" if merge_debug
-            dest = ""
+      def hash_only_merge(merge_onto, merge_with)
+        hash_only_merge!(merge_onto.dup, merge_with.dup)
+      end
+
+      # Deep merge without Array merge.
+      # `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.
+      def hash_only_merge!(merge_onto, merge_with)
+        # If there are two Hashes, recursively merge.
+        if merge_onto.kind_of?(Hash) && merge_with.kind_of?(Hash)
+          merge_with.each do |key, merge_with_value|
+            merge_onto[key] = hash_only_merge!(merge_onto[key], merge_with_value)
           end
-        elsif overwrite_unmergeable
-          dest = source
+          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
-        dest
       end
 
-      def deep_merge(source, dest, options = {})
-        deep_merge!(source.dup, dest.dup, options)
+      # Checks for attempted use of subtractive merge, which was removed for
+      # Chef 11.0. If subtractive merge use is detected, will raise an
+      # InvalidSubtractiveMerge exception.
+      def raise_if_knockout_used!(obj)
+        if uses_knockout?(obj)
+          raise InvalidSubtractiveMerge, "subtractive merge with !merge is no longer supported"
+        end
       end
 
-      def clear_or_nil(obj)
-        if obj.respond_to?(:clear)
-          obj.clear
+      # Checks for attempted use of subtractive merge in +obj+.
+      def uses_knockout?(obj)
+        case obj
+        when String
+          obj =~ OLD_KNOCKOUT_MATCH
+        when Array
+          obj.any? {|element| element.respond_to?(:gsub) && element =~ OLD_KNOCKOUT_MATCH }
         else
-          obj = nil
+          false
         end
-        obj
       end
 
-    end
+      def deep_merge(source, dest)
+        deep_merge!(source.dup, dest.dup)
+      end
 
+    end
   end
 end
 

data/lib/chef/mixin/deprecation.rb

@@ -18,7 +18,42 @@
 
 class Chef
   module Mixin
+
+
+      def self.deprecated_constants
+        @deprecated_constants ||= {}
+      end
+
+      # Add a deprecated constant to the Chef::Mixin namespace.
+      # === Arguments
+      # * name: the constant name, as a relative symbol.
+      # * replacement: the constant to return instead.
+      # * message: A message telling the user what to do instead.
+      # === Example:
+      #   deprecate_constant(:RecipeDefinitionDSLCore, Chef::DSL::Recipe, <<-EOM)
+      #     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}
+      end
+
+      # Const missing hook to look up deprecated constants defined with
+      # deprecate_constant. Emits a warning to the logger and returns the
+      # replacement constant. Will call super, most likely causing an exception
+      # for the missing constant, if +name+ is not found in the
+      # deprecated_constants collection.
+      def self.const_missing(name)
+        if new_const = deprecated_constants[name]
+          Chef::Log.warn(new_const[:message])
+          Chef::Log.warn("Called from: \n#{caller[0...3].map {|l| "\t#{l}"}.join("\n")}")
+          new_const[:replacement]
+        else
+          super
+        end
+      end
+
     module Deprecation
+
       class DeprecatedObjectProxyBase
         KEEPERS = %w{__id__ __send__ instance_eval == equal? initialize object_id}
         instance_methods.each { |method_name| undef_method(method_name) unless KEEPERS.include?(method_name.to_s)}

data/lib/chef/mixin/file_class.rb

@@ -25,15 +25,6 @@ class Chef
       def file_class
         @host_os_file ||= if Chef::Platform.windows?
           require 'chef/win32/file'
-          begin
-            Chef::ReservedNames::Win32::File.verify_links_supported!
-          rescue Chef::Exceptions::Win32APIFunctionNotImplemented => e
-            message = "Link resource is not supported on this version of Windows"
-            message << ": #{node[:kernel][:name]}" if node
-            message << " (#{node[:platform_version]})" if node
-            Chef::Log.fatal(message)
-            raise e
-          end
           Chef::ReservedNames::Win32::File
         else
           ::File

data/lib/chef/mixin/language.rb

@@ -16,234 +16,33 @@
 # limitations under the License.
 #
 
-require 'chef/search/query'
-require 'chef/data_bag'
-require 'chef/data_bag_item'
-require 'chef/encrypted_data_bag_item'
+require 'chef/dsl/platform_introspection'
+require 'chef/dsl/data_query'
+require 'chef/mixin/deprecation'
 
 class Chef
   module Mixin
-    module Language
 
-      # Implementation class for determining platform dependent values
-      class PlatformDependentValue
-
-        # Create a platform dependent value object.
-        # === Arguments
-        # platform_hash (Hash) a hash of the same structure as Chef::Platform,
-        # like this:
-        #   {
-        #     :debian => {:default => 'the value for all debian'}
-        #     [:centos, :redhat, :fedora] => {:default => "value for all EL variants"}
-        #     :ubuntu => { :default => "default for ubuntu", '10.04' => "value for 10.04 only"},
-        #     :default => "the default when nothing else matches"
-        #   }
-        # * platforms can be specified as Symbols or Strings
-        # * multiple platforms can be grouped by using an Array as the key
-        # * values for platforms need to be Hashes of the form:
-        #   {platform_version => value_for_that_version}
-        # * the exception to the above is the default value, which is given as
-        #   :default => default_value
-        def initialize(platform_hash)
-          @values = {}
-          platform_hash.each { |platforms, value| set(platforms, value)}
-        end
-
-        def value_for_node(node)
-          platform, version = node[:platform].to_s, node[:platform_version].to_s
-          if @values.key?(platform) && @values[platform].key?(version)
-            @values[platform][version]
-          elsif @values.key?(platform) && @values[platform].key?("default")
-            @values[platform]["default"]
-          elsif @values.key?("default")
-            @values["default"]
-          else
-            nil
-          end
-        end
-
-        private
-
-        def set(platforms, value)
-          if platforms.to_s == 'default'
-            @values["default"] = value
-          else
-            assert_valid_platform_values!(platforms, value)
-            Array(platforms).each { |platform| @values[platform.to_s] = normalize_keys(value)}
-            value
-          end
-        end
-
-        def normalize_keys(hash)
-          hash.inject({}) do |h, key_value|
-            keys, value = *key_value
-            Array(keys).each do |key|
-              h[key.to_s] = value
-            end
-            h
-          end
-        end
-
-        def assert_valid_platform_values!(platforms, value)
-          unless value.kind_of?(Hash)
-            msg = "platform dependent values must be specified in the format :platform => {:version => value} "
-            msg << "you gave a value #{value.inspect} for platform(s) #{platforms}"
-            raise ArgumentError, msg
-          end
-        end
-      end
-
-
-
-      # Given a hash similar to the one we use for Platforms, select a value from the hash.  Supports
-      # per platform defaults, along with a single base default. Arrays may be passed as hash keys and
-      # will be expanded.
-      #
-      # === Parameters
-      # platform_hash:: A platform-style hash.
-      #
-      # === Returns
-      # value:: Whatever the most specific value of the hash is.
-      def value_for_platform(platform_hash)
-        PlatformDependentValue.new(platform_hash).value_for_node(node)
-      end 
-
-      # Given a list of platforms, returns true if the current recipe is being run on a node with
-      # that platform, false otherwise.
-      #
-      # === Parameters
-      # args:: A list of platforms. Each platform can be in string or symbol format.
-      #
-      # === Returns
-      # true:: If the current platform is in the list
-      # false:: If the current platform is not in the list
-      def platform?(*args)
-        has_platform = false
-
-        args.flatten.each do |platform|
-          has_platform = true if platform.to_s == node[:platform]
-        end
-
-        has_platform
-      end
-
-
-
-     # Implementation class for determining platform family dependent values
-      class PlatformFamilyDependentValue
-
-        # Create a platform family dependent value object.
-        # === Arguments
-        # platform_family_hash (Hash) a map of platform families to values. 
-        # like this:
-        #   {
-        #     :rhel => "value for all EL variants"
-        #     :fedora =>  "value for fedora variants fedora and amazon" ,
-	#     [:fedora, :rhel] => "value for all known redhat variants"
-        #     :debian =>  "value for debian variants including debian, ubuntu, mint" ,
-        #     :default => "the default when nothing else matches"
-        #   }
-        # * platform families can be specified as Symbols or Strings
-        # * multiple platform families can be grouped by using an Array as the key
-        # * values for platform families can be any object, with no restrictions. Some examples: 
-	#   - [:stop, :start]
-	#   - "mysql-devel"
-        #   - { :key => "value" }
-        def initialize(platform_family_hash)
-          @values = {}
-	  @values["default"] = nil
-          platform_family_hash.each { |platform_families, value| set(platform_families, value)}
-        end
-
-        def value_for_node(node)
-	  if node.key?(:platform_family)
-            platform_family = node[:platform_family].to_s
-            if @values.key?(platform_family)
-              @values[platform_family]
-	    else
-              @values["default"]
-            end
-	  else
-            @values["default"]
-	  end
-        end
-
-        private
-
-        def set(platform_family, value)
-          if platform_family.to_s == 'default'
-            @values["default"] = value
-          else
-            Array(platform_family).each { |family| @values[family.to_s] = value }
-            value
-          end
-        end
-      end
-
-
-      # Given a hash mapping platform families to values, select a value from the hash. Supports a single
-      # base default if platform family is not in the map. Arrays may be passed as hash keys and will be 
-      # expanded.  
-      #
-      # === Parameters
-      # platform_family_hash:: A hash in the form { platform_family_name => value } 
-      #
-      # === Returns
-      # value:: Whatever the most specific value of the hash is.
-      def value_for_platform_family(platform_family_hash) 
-        PlatformFamilyDependentValue.new(platform_family_hash).value_for_node(node)
-      end
-      
-      # Given a list of platform families, returns true if the current recipe is being run on a 
-      # node within that platform family, false otherwise. 
-      #
-      # === Parameters
-      # args:: A list of platform families. Each platform family can be in string or symbol format.  
-      #
-      # === Returns
-      # true:: if the current node platform family is in the list. 
-      # false:: if the current node platform family is not in the list. 
-      def platform_family?(*args)
-        has_pf = false
-        args.flatten.each do |platform_family|
-	  has_pf = true if platform_family.to_s == node[:platform_family] 
-        end 
-        has_pf
-      end	
-      
-      def search(*args, &block)
-        # If you pass a block, or have at least the start argument, do raw result parsing
-        #
-        # Otherwise, do the iteration for the end user
-        if Kernel.block_given? || args.length >= 4
-          Chef::Search::Query.new.search(*args, &block)
-        else
-          results = Array.new
-          Chef::Search::Query.new.search(*args) do |o|
-            results << o
-          end
-          results
-        end
-      end
-
-      def data_bag(bag)
-        DataBag.validate_name!(bag.to_s)
-        rbag = DataBag.load(bag)
-        rbag.keys
-      rescue Exception
-        Log.error("Failed to list data bag items in data bag: #{bag.inspect}")
-        raise
-      end
-
-      def data_bag_item(bag, item)
-        DataBag.validate_name!(bag.to_s)
-        DataBagItem.validate_id!(item)
-        DataBagItem.load(bag, item)
-      rescue Exception
-        Log.error("Failed to load data bag item: #{bag.inspect} #{item.inspect}")
-        raise
-      end
+    # == [DEPRECATED] Chef::Mixin::DeprecatedLanguageModule
+    # This module is a temporary replacement for the previous
+    # Chef::Mixin::Language. That module's functionality was split into two
+    # modules, Chef::DSL::PlatformIntrospection, and Chef::DSL::DataQuery.
+    #
+    # This module includes both PlatformIntrospection and DataQuery to provide
+    # the same interfaces and behavior as the prior Mixin::Language.
+    #
+    # This module is loaded via const_missing hook when Chef::Mixin::Language
+    # is accessed. See chef/mixin/deprecation for details.
+    module DeprecatedLanguageModule
+
+      include Chef::DSL::PlatformIntrospection
+      include Chef::DSL::DataQuery
 
     end
+
+    deprecate_constant(:Language, DeprecatedLanguageModule, <<-EOM)
+Chef::Mixin::Language is deprecated. Use either (or both)
+Chef::DSL::PlatformIntrospection or Chef::DSL::DataQuery instead.
+EOM
   end
 end