chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/knife/show.rb

@@ -0,0 +1,32 @@
+require 'chef/chef_fs/knife'
+require 'chef/chef_fs/file_system'
+
+class Chef
+  class Knife
+    class Show < Chef::ChefFS::Knife
+      banner "knife show [PATTERN1 ... PATTERNn]"
+
+      common_options
+
+      def run
+        # Get the matches (recursively)
+        pattern_args.each do |pattern|
+          Chef::ChefFS::FileSystem.list(chef_fs, pattern) do |result|
+            if result.dir?
+              STDERR.puts "#{result.path_for_printing}: is a directory" if pattern.exact_path
+            else
+              begin
+                value = result.read
+                puts "#{result.path_for_printing}:"
+                output(format_for_display(value))
+              rescue Chef::ChefFS::FileSystem::NotFoundError
+                STDERR.puts "#{result.path_for_printing}: No such file or directory"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/knife/ssh.rb

@@ -146,9 +146,9 @@ class Chef
                    if !config[:override_attribute] && item[:cloud] and item[:cloud][:public_hostname]
                      i = item[:cloud][:public_hostname]
                    elsif config[:override_attribute]
-                     i = format_for_display(item)[config[:override_attribute]]
+                     i = extract_nested_value(item, config[:override_attribute])
                    else
-                     i = format_for_display(item)[config[:attribute]]
+                     i = extract_nested_value(item, config[:attribute])
                    end
                    # next if we couldn't find the specified attribute in the returned node object
                    next if i.nil?
@@ -415,6 +415,10 @@ class Chef
                              Chef::Config[:knife][:ssh_identity_file])
       end
 
+      def extract_nested_value(data_structure, path_spec)
+        ui.presenter.extract_nested_value(data_structure, path_spec)
+      end
+
       def run
         extend Chef::Mixin::Command
 

data/lib/chef/knife/upload.rb

@@ -0,0 +1,50 @@
+require 'chef/chef_fs/knife'
+require 'chef/chef_fs/command_line'
+
+class Chef
+  class Knife
+    class Upload < Chef::ChefFS::Knife
+      banner "knife upload PATTERNS"
+
+      common_options
+
+      option :recurse,
+        :long => '--[no-]recurse',
+        :boolean => true,
+        :default => true,
+        :description => "List directories recursively."
+
+      option :purge,
+        :long => '--[no-]purge',
+        :boolean => true,
+        :default => false,
+        :description => "Delete matching local files and directories that do not exist remotely."
+
+      option :force,
+        :long => '--[no-]force',
+        :boolean => true,
+        :default => false,
+        :description => "Force upload of files even if they match (quicker and harmless, but doesn't print out what it changed)"
+
+      option :dry_run,
+        :long => '--dry-run',
+        :short => '-n',
+        :boolean => true,
+        :default => false,
+        :description => "Don't take action, only print what would happen"
+
+      def run
+        if name_args.length == 0
+          show_usage
+          ui.fatal("Must specify at least one argument.  If you want to upload everything in this directory, type \"knife upload .\"")
+          exit 1
+        end
+
+        pattern_args.each do |pattern|
+          Chef::ChefFS::FileSystem.copy_to(pattern, local_fs, chef_fs, config[:recurse] ? nil : 1, config)
+        end
+      end
+    end
+  end
+end
+

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,70 @@ 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 = ""
-          end
-        elsif overwrite_unmergeable
-          dest = source
+      # 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
-        dest
-      end
-
-      def deep_merge(source, dest, options = {})
-        deep_merge!(source.dup, dest.dup, options)
       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/language.rb

@@ -16,233 +16,20 @@
 # 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'
 
 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
+    # == [DEPRECATED] Chef::Mixin::Language
+    # This module is deprecated and remains only for backwards compatibility.
+    #
+    # See Chef::DSL::PlatformIntrospection and Chef::DSL::DataQuery
+    module Language
 
-      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
+      include Chef::DSL::PlatformIntrospection
+      include Chef::DSL::DataQuery
 
     end
   end