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

data/lib/chef/node/attribute_collections.rb

@@ -0,0 +1,206 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2012 Opscode, 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
+  class Node
+
+    # == AttrArray
+    # AttrArray is identical to Array, except that it keeps a reference to the
+    # "root" (Chef::Node::Attribute) object, and will trigger a cache
+    # invalidation on that object when mutated.
+    class AttrArray < Array
+
+      MUTATOR_METHODS = [
+        :<<,
+        :[]=,
+        :clear,
+        :collect!,
+        :compact!,
+        :default=,
+        :default_proc=,
+        :delete,
+        :delete_at,
+        :delete_if,
+        :fill,
+        :flatten!,
+        :insert,
+        :keep_if,
+        :map!,
+        :merge!,
+        :pop,
+        :push,
+        :update,
+        :reject!,
+        :reverse!,
+        :replace,
+        :select!,
+        :shift,
+        :slice!,
+        :sort!,
+        :sort_by!,
+        :uniq!,
+        :unshift
+      ]
+
+      # For all of the methods that may mutate an Array, we override them to
+      # also invalidate the cached merged_attributes on the root
+      # Node::Attribute object.
+      MUTATOR_METHODS.each do |mutator|
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+          def #{mutator}(*args, &block)
+            root.reset_cache
+            super
+          end
+        METHOD_DEFN
+      end
+
+      attr_reader :root
+
+      def initialize(root, data)
+        @root = root
+        super(data)
+      end
+
+      def dup
+        Array.new(map {|e| e.dup})
+      end
+
+    end
+
+    # == VividMash
+    # VividMash is identical to a Mash, with a few exceptions:
+    # * It has a reference to the root Chef::Node::Attribute to which it
+    #   belongs, and will trigger cache invalidation on that object when
+    #   mutated.
+    # * It auto-vivifies, that is a reference to a missing element will result
+    #   in the creation of a new VividMash for that key. (This only works when
+    #   using the element reference method, `[]` -- other methods, such as
+    #   #fetch, work as normal).
+    # * It supports a set_unless flag (via the root Attribute object) which
+    #   allows `||=` style behavior (`||=` does not work with
+    #   auto-vivification). This is only implemented for #[]=; methods such as
+    #   #store work as normal.
+    # * attr_accessor style element set and get are supported via method_missing
+    class VividMash < Mash
+      attr_reader :root
+
+      # Methods that mutate a VividMash. Each of them is overridden so that it
+      # also invalidates the cached merged_attributes on the root Attribute
+      # object.
+      MUTATOR_METHODS = [
+        :clear,
+        :delete,
+        :delete_if,
+        :keep_if,
+        :merge!,
+        :update,
+        :reject!,
+        :replace,
+        :select!,
+        :shift
+      ]
+
+      # For all of the mutating methods on Mash, override them so that they
+      # also invalidate the cached `merged_attributes` on the root Attribute
+      # object.
+      MUTATOR_METHODS.each do |mutator|
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+          def #{mutator}(*args, &block)
+            root.reset_cache
+            super
+          end
+        METHOD_DEFN
+      end
+
+      def initialize(root, data={})
+        @root = root
+        super(data)
+      end
+
+      def [](key)
+        value = super
+        if !key?(key)
+          value = self.class.new(root)
+          self[key] = value
+        else
+          value
+        end
+      end
+
+      def []=(key, value)
+        if set_unless? && key?(key)
+          self[key]
+        else
+          root.reset_cache
+          super
+        end
+      end
+
+      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 set_unless?
+        @root.set_unless?
+      end
+
+      def convert_key(key)
+        super
+      end
+
+      # Mash uses #convert_value to mashify values on input.
+      # We override it here to convert hash or array values to VividMash or
+      # AttrArray for consistency and to ensure that the added parts of the
+      # attribute tree will have the correct cache invalidation behavior.
+      def convert_value(value)
+        case value
+        when VividMash
+          value
+        when Hash
+          VividMash.new(root, value)
+        when Array
+          AttrArray.new(root, value)
+        else
+          value
+        end
+      end
+
+      def dup
+        Mash.new(self)
+      end
+
+    end
+
+  end
+end

data/lib/chef/node/immutable_collections.rb

@@ -0,0 +1,186 @@
+
+class Chef
+  class Node
+
+    module Immutablize
+      def immutablize(value)
+        case value
+        when Hash
+          ImmutableMash.new(value)
+        when Array
+          ImmutableArray.new(value)
+        else
+          value
+        end
+      end
+    end
+
+    # == ImmutableArray
+    # ImmutableArray is used to implement Array collections when reading node
+    # attributes.
+    #
+    # ImmutableArray acts like an ordinary Array, except:
+    # * Methods that mutate the array are overridden to raise an error, making
+    #   the collection more or less immutable.
+    # * Since this class stores values computed from a parent
+    #   Chef::Node::Attribute's values, it overrides all reader methods to
+    #   detect staleness and raise an error if accessed when stale.
+    class ImmutableArray < Array
+      include Immutablize
+
+      alias :internal_push :<<
+      private :internal_push
+
+      # A list of methods that mutate Array. Each of these is overridden to
+      # raise an error, making this instances of this class more or less
+      # immutable.
+      DISALLOWED_MUTATOR_METHODS = [
+        :<<,
+        :[]=,
+        :clear,
+        :collect!,
+        :compact!,
+        :default=,
+        :default_proc=,
+        :delete,
+        :delete_at,
+        :delete_if,
+        :fill,
+        :flatten!,
+        :insert,
+        :keep_if,
+        :map!,
+        :merge!,
+        :pop,
+        :push,
+        :update,
+        :reject!,
+        :reverse!,
+        :replace,
+        :select!,
+        :shift,
+        :slice!,
+        :sort!,
+        :sort_by!,
+        :uniq!,
+        :unshift
+      ]
+
+      def initialize(array_data)
+        array_data.each do |value|
+          internal_push(immutablize(value))
+        end
+      end
+
+      # Redefine all of the methods that mutate a Hash to raise an error when called.
+      # This is the magic that makes this object "Immutable"
+      DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
+        # Ruby 1.8 blocks can't have block arguments, so we must use string eval:
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+          def #{mutator_method_name}(*args, &block)
+            msg = "Node attributes are read-only when you do not specify which precedence level to set. " +
+            %Q(To set an attribute use code like `node.default["key"] = "value"')
+            raise Exceptions::ImmutableAttributeModification, msg
+          end
+        METHOD_DEFN
+      end
+
+      def dup
+        Array.new(map {|e| e.dup })
+      end
+
+    end
+
+    # == ImmutableMash
+    # ImmutableMash implements Hash/Dict behavior for reading values from node
+    # attributes.
+    #
+    # ImmutableMash acts like a Mash (Hash that is indifferent to String or
+    # Symbol keys), with some important exceptions:
+    # * Methods that mutate state are overridden to raise an error instead.
+    # * Methods that read from the collection are overriden so that they check
+    #   if the Chef::Node::Attribute has been modified since an instance of
+    #   this class was generated. An error is raised if the object detects that
+    #   it is stale.
+    # * Values can be accessed in attr_reader-like fashion via method_missing.
+    class ImmutableMash < Mash
+
+      include Immutablize
+
+      alias :internal_set :[]=
+      private :internal_set
+
+      DISALLOWED_MUTATOR_METHODS = [
+        :[]=,
+        :clear,
+        :collect!,
+        :default=,
+        :default_proc=,
+        :delete,
+        :delete_if,
+        :keep_if,
+        :map!,
+        :merge!,
+        :update,
+        :reject!,
+        :replace,
+        :select!,
+        :shift
+      ]
+
+      def initialize(mash_data)
+        mash_data.each do |key, value|
+          internal_set(key, immutablize(value))
+        end
+      end
+
+      alias :attribute? :has_key?
+
+      # Redefine all of the methods that mutate a Hash to raise an error when called.
+      # This is the magic that makes this object "Immutable"
+      DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
+        # Ruby 1.8 blocks can't have block arguments, so we must use string eval:
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+        def #{mutator_method_name}(*args, &block)
+          msg = "Node attributes are read-only when you do not specify which precedence level to set. " +
+          %Q(To set an attribute use code like `node.default["key"] = "value"')
+          raise Exceptions::ImmutableAttributeModification, msg
+        end
+        METHOD_DEFN
+      end
+
+      def method_missing(symbol, *args)
+        if args.empty?
+          if key?(symbol)
+            self[symbol]
+          else
+            raise NoMethodError, "Undefined method or attribute `#{symbol}' on `node'"
+          end
+        # This will raise a ImmutableAttributeModification error:
+        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'"
+        end
+      end
+
+      # Mash uses #convert_value to mashify values on input.
+      # Since we're handling this ourselves, override it to be a no-op
+      def convert_value(value)
+        value
+      end
+
+      # NOTE: #default and #default= are likely to be pretty confusing. For a
+      # regular ruby Hash, they control what value is returned for, e.g.,
+      #   hash[:no_such_key] #=> hash.default
+      # Of course, 'default' has a specific meaning in Chef-land
+
+      def dup
+        Mash.new(self)
+      end
+
+    end
+
+  end
+end

data/lib/chef/platform.rb

@@ -16,506 +16,14 @@
 # limitations under the License.
 #
 
-require 'chef/config'
-require 'chef/log'
-require 'chef/mixin/params_validate'
-
-# Actually, this file depends on nearly every provider in chef, but actually
-# requiring them causes circular requires resulting in uninitialized constant
-# errors.
-require 'chef/provider'
-require 'chef/provider/log'
-require 'chef/provider/user'
-require 'chef/provider/group'
-require 'chef/provider/mount'
-require 'chef/provider/service'
-require 'chef/provider/package'
-
+require 'chef/platform/provider_mapping'
+require 'chef/platform/query_helpers'
 
 class Chef
   class Platform
 
-    class << self
-      attr_writer :platforms
-
-      def platforms
-        @platforms ||= {
-          :mac_os_x => {
-            :default => {
-              :package => Chef::Provider::Package::Macports,
-              :service => Chef::Provider::Service::Macosx,
-              :user => Chef::Provider::User::Dscl,
-              :group => Chef::Provider::Group::Dscl
-            }
-          },
-          :mac_os_x_server => {
-            :default => {
-              :package => Chef::Provider::Package::Macports,
-              :service => Chef::Provider::Service::Macosx,
-              :user => Chef::Provider::User::Dscl,
-              :group => Chef::Provider::Group::Dscl
-            }
-          },
-          :freebsd => {
-            :default => {
-              :group   => Chef::Provider::Group::Pw,
-              :package => Chef::Provider::Package::Freebsd,
-              :service => Chef::Provider::Service::Freebsd,
-              :user    => Chef::Provider::User::Pw,
-              :cron    => Chef::Provider::Cron
-            }
-          },
-          :ubuntu   => {
-            :default => {
-              :package => Chef::Provider::Package::Apt,
-              :service => Chef::Provider::Service::Debian,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :gcel   => {
-            :default => {
-              :package => Chef::Provider::Package::Apt,
-              :service => Chef::Provider::Service::Debian,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :linaro   => {
-            :default => {
-              :package => Chef::Provider::Package::Apt,
-              :service => Chef::Provider::Service::Debian,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :raspbian   => {
-            :default => {
-              :package => Chef::Provider::Package::Apt,
-              :service => Chef::Provider::Service::Debian,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :linuxmint   => {
-            :default => {
-              :package => Chef::Provider::Package::Apt,
-              :service => Chef::Provider::Service::Upstart,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :debian => {
-            :default => {
-              :package => Chef::Provider::Package::Apt,
-              :service => Chef::Provider::Service::Debian,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            },
-            "6.0" => {
-              :service => Chef::Provider::Service::Insserv
-            }
-          },
-          :xenserver   => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Yum,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :centos   => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Yum,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :amazon   => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Yum,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :scientific => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Yum,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :fedora   => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Yum,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :suse     => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Zypper,
-              :group => Chef::Provider::Group::Suse
-            }
-          },
-          :oracle  => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Yum,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :redhat   => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Yum,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :gentoo   => {
-            :default => {
-              :package => Chef::Provider::Package::Portage,
-              :service => Chef::Provider::Service::Gentoo,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :arch   => {
-            :default => {
-              :package => Chef::Provider::Package::Pacman,
-              :service => Chef::Provider::Service::Arch,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
-          :mswin => {
-            :default => {
-              :env =>  Chef::Provider::Env::Windows,
-              :service => Chef::Provider::Service::Windows,
-              :user => Chef::Provider::User::Windows,
-              :group => Chef::Provider::Group::Windows,
-              :mount => Chef::Provider::Mount::Windows
-            }
-          },
-          :mingw32 => {
-            :default => {
-              :env =>  Chef::Provider::Env::Windows,
-              :service => Chef::Provider::Service::Windows,
-              :user => Chef::Provider::User::Windows,
-              :group => Chef::Provider::Group::Windows,
-              :mount => Chef::Provider::Mount::Windows
-            }
-          },
-          :windows => {
-            :default => {
-              :env =>  Chef::Provider::Env::Windows,
-              :service => Chef::Provider::Service::Windows,
-              :user => Chef::Provider::User::Windows,
-              :group => Chef::Provider::Group::Windows,
-              :mount => Chef::Provider::Mount::Windows
-            }
-          },
-          :solaris  => {},
-          :openindiana => {
-            :default => {
-              :service => Chef::Provider::Service::Solaris,
-              :package => Chef::Provider::Package::Ips,
-              :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod
-            }
-          },
-          :opensolaris => {
-            :default => {
-              :service => Chef::Provider::Service::Solaris,
-              :package => Chef::Provider::Package::Ips,
-              :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod
-            }
-          },
-          :nexentacore => {
-            :default => {
-              :service => Chef::Provider::Service::Solaris,
-              :package => Chef::Provider::Package::Solaris,
-              :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod
-            }
-          },
-          :omnios => {
-            :default => {
-              :service => Chef::Provider::Service::Solaris,
-              :package => Chef::Provider::Package::Ips,
-              :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris,
-            }
-          },
-          :solaris2 => {
-            :default => {
-              :service => Chef::Provider::Service::Solaris,
-              :package => Chef::Provider::Package::Ips,
-              :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris
-            },
-            "5.9" => {
-              :service => Chef::Provider::Service::Solaris,
-              :package => Chef::Provider::Package::Solaris,
-              :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris
-            },
-            "5.10" => {
-              :service => Chef::Provider::Service::Solaris,
-              :package => Chef::Provider::Package::Solaris,
-              :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris
-            }
-          },
-          :smartos => {
-            :default => {
-              :service => Chef::Provider::Service::Solaris,
-              :package => Chef::Provider::Package::SmartOS,
-              :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris
-            }
-          },
-          :netbsd => {
-            :default => {
-              :service => Chef::Provider::Service::Freebsd,
-              :group => Chef::Provider::Group::Groupmod
-            }
-          },
-          :openbsd => {
-            :default => {
-              :group => Chef::Provider::Group::Usermod
-            }
-          },
-          :hpux => {
-            :default => {
-              :group => Chef::Provider::Group::Usermod
-            }
-          },
-          :aix => {
-            :default => {
-              :group => Chef::Provider::Group::Aix
-            }
-          },
-          :default  => {
-            :file => Chef::Provider::File,
-            :directory => Chef::Provider::Directory,
-            :link => Chef::Provider::Link,
-            :template => Chef::Provider::Template,
-            :remote_directory => Chef::Provider::RemoteDirectory,
-            :execute => Chef::Provider::Execute,
-            :mount => Chef::Provider::Mount::Mount,
-            :script => Chef::Provider::Script,
-            :service => Chef::Provider::Service::Init,
-            :perl => Chef::Provider::Script,
-            :python => Chef::Provider::Script,
-            :ruby => Chef::Provider::Script,
-            :bash => Chef::Provider::Script,
-            :csh => Chef::Provider::Script,
-            :user => Chef::Provider::User::Useradd,
-            :group => Chef::Provider::Group::Gpasswd,
-            :http_request => Chef::Provider::HttpRequest,
-            :route => Chef::Provider::Route,
-            :ifconfig => Chef::Provider::Ifconfig,
-            :ruby_block => Chef::Provider::RubyBlock,
-            :whyrun_safe_ruby_block => Chef::Provider::WhyrunSafeRubyBlock,
-            :erl_call => Chef::Provider::ErlCall,
-            :log => Chef::Provider::Log::ChefLog
-          }
-        }
-      end
-
-      include Chef::Mixin::ParamsValidate
-
-      def find(name, version)
-        provider_map = platforms[:default].clone
-
-        name_sym = name
-        if name.kind_of?(String)
-          name.downcase!
-          name.gsub!(/\s/, "_")
-          name_sym = name.to_sym
-        end
-
-        if platforms.has_key?(name_sym)
-          if platforms[name_sym].has_key?(version)
-            Chef::Log.debug("Platform #{name.to_s} version #{version} found")
-            if platforms[name_sym].has_key?(:default)
-              provider_map.merge!(platforms[name_sym][:default])
-            end
-            provider_map.merge!(platforms[name_sym][version])
-          elsif platforms[name_sym].has_key?(:default)
-            provider_map.merge!(platforms[name_sym][:default])
-          end
-        else
-          Chef::Log.debug("Platform #{name} not found, using all defaults. (Unsupported platform?)")
-        end
-        provider_map
-      end
-
-      def find_platform_and_version(node)
-        platform = nil
-        version = nil
-
-        if node[:platform]
-          platform = node[:platform]
-        elsif node.attribute?("os")
-          platform = node[:os]
-        end
-
-        raise ArgumentError, "Cannot find a platform for #{node}" unless platform
-
-        if node[:platform_version]
-          version = node[:platform_version]
-        elsif node[:os_version]
-          version = node[:os_version]
-        elsif node[:os_release]
-          version = node[:os_release]
-        end
-
-        raise ArgumentError, "Cannot find a version for #{node}" unless version
-
-        return platform, version
-      end
-
-      def provider_for_resource(resource, action=:nothing)
-        node = resource.run_context && resource.run_context.node
-        raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node
-        provider = find_provider_for_node(node, resource).new(resource, resource.run_context)
-        provider.action = action
-        provider
-      end
-
-      def provider_for_node(node, resource_type)
-        raise NotImplementedError, "#{self.class.name} no longer supports #provider_for_node"
-        find_provider_for_node(node, resource_type).new(node, resource_type)
-      end
-
-      def find_provider_for_node(node, resource_type)
-        platform, version = find_platform_and_version(node)
-        provider = find_provider(platform, version, resource_type)
-      end
-
-      def set(args)
-        validate(
-          args,
-          {
-            :platform => {
-              :kind_of => Symbol,
-              :required => false,
-            },
-            :version => {
-              :kind_of => String,
-              :required => false,
-            },
-            :resource => {
-              :kind_of => Symbol,
-            },
-            :provider => {
-              :kind_of => [ String, Symbol, Class ],
-            }
-          }
-        )
-        if args.has_key?(:platform)
-          if args.has_key?(:version)
-            if platforms.has_key?(args[:platform])
-              if platforms[args[:platform]].has_key?(args[:version])
-                platforms[args[:platform]][args[:version]][args[:resource].to_sym] = args[:provider]
-              else
-                platforms[args[:platform]][args[:version]] = {
-                  args[:resource].to_sym => args[:provider]
-                }
-              end
-            else
-              platforms[args[:platform]] = {
-                args[:version] => {
-                  args[:resource].to_sym => args[:provider]
-                }
-              }
-            end
-          else
-            if platforms.has_key?(args[:platform])
-              if platforms[args[:platform]].has_key?(:default)
-                platforms[args[:platform]][:default][args[:resource].to_sym] = args[:provider]
-              else
-                platforms[args[:platform]] = { :default => { args[:resource].to_sym => args[:provider] } }
-              end
-            else
-              platforms[args[:platform]] = {
-                :default => {
-                  args[:resource].to_sym => args[:provider]
-                }
-              }
-            end
-          end
-        else
-          if platforms.has_key?(:default)
-            platforms[:default][args[:resource].to_sym] = args[:provider]
-          else
-            platforms[:default] = {
-              args[:resource].to_sym => args[:provider]
-            }
-          end
-        end
-      end
-
-      def find_provider(platform, version, resource_type)
-        pmap = Chef::Platform.find(platform, version)
-        provider_klass = explicit_provider(platform, version, resource_type) ||
-                         platform_provider(platform, version, resource_type) ||
-                         resource_matching_provider(platform, version, resource_type)
-
-        raise ArgumentError, "Cannot find a provider for #{resource_type} on #{platform} version #{version}" if provider_klass.nil?
-
-        provider_klass
-      end
-
-      def windows?
-        if RUBY_PLATFORM =~ /mswin|mingw|windows/
-          true
-        else
-          false
-        end
-      end
-
-      private
-
-        def explicit_provider(platform, version, resource_type)
-          resource_type.kind_of?(Chef::Resource) ? resource_type.provider : nil
-        end
-
-        def platform_provider(platform, version, resource_type)
-          pmap = Chef::Platform.find(platform, version)
-          rtkey = resource_type.kind_of?(Chef::Resource) ? resource_type.resource_name.to_sym : resource_type
-          pmap.has_key?(rtkey) ? pmap[rtkey] : nil
-        end
-
-        def resource_matching_provider(platform, version, resource_type)
-          if resource_type.kind_of?(Chef::Resource)
-            begin
-              Chef::Provider.const_get(resource_type.class.to_s.split('::').last)
-            rescue NameError
-              nil
-            end
-          else
-            nil
-          end
-        end
-
-    end
+    # Functionality for this class is defined in chef/platform/provider_mapping
+    # and chef/platform/query_helpers
 
   end
 end