chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/lib/chef/provider/service/freebsd.rb

@@ -27,6 +27,10 @@ class Chef
 
         attr_reader :enabled_state_found
 
+        provides :service, os: [ "freebsd", "netbsd" ]
+
+        include Chef::Mixin::ShellOut
+
         def initialize(new_resource, run_context)
           super
           @enabled_state_found = false
@@ -46,6 +50,7 @@ class Chef
 
           Chef::Log.debug("#{current_resource} found at #{init_command}")
 
+          @status_load_success = true
           determine_current_status!  # see Chef::Provider::Service::Simple
 
           determine_enabled_status!
@@ -58,6 +63,7 @@ class Chef
           requirements.assert(:start, :enable, :reload, :restart) do |a|
             a.assertion { init_command }
             a.failure_message Chef::Exceptions::Service, "#{new_resource}: unable to locate the rc.d script"
+            a.whyrun("Assuming rc.d script will be installed by a previous action.")
           end
 
           requirements.assert(:all_actions) do |a|
@@ -68,7 +74,7 @@ class Chef
           end
 
           requirements.assert(:start, :enable, :reload, :restart) do |a|
-            a.assertion { init_command && service_enable_variable_name != nil }
+            a.assertion { service_enable_variable_name != nil }
             a.failure_message Chef::Exceptions::Service, "Could not find the service name in #{init_command} and rcvar"
             # No recovery in whyrun mode - the init file is present but not correct.
           end

data/lib/chef/provider/service/gentoo.rb

@@ -19,8 +19,12 @@
 
 require 'chef/provider/service/init'
 require 'chef/mixin/command'
+require 'chef/util/path_helper'
 
 class Chef::Provider::Service::Gentoo < Chef::Provider::Service::Init
+
+  provides :service, platform_family: "gentoo"
+
   def load_current_resource
 
     @new_resource.supports[:status] = true
@@ -29,7 +33,7 @@ class Chef::Provider::Service::Gentoo < Chef::Provider::Service::Init
     super
 
     @current_resource.enabled(
-      Dir.glob("/etc/runlevels/**/#{@current_resource.service_name}").any? do |file|
+      Dir.glob("/etc/runlevels/**/#{Chef::Util::PathHelper.escape_glob(@current_resource.service_name)}").any? do |file|
         @found_script = true
         exists = ::File.exists? file
         readable = ::File.readable? file

data/lib/chef/provider/service/init.rb

@@ -26,6 +26,8 @@ class Chef
 
         attr_accessor :init_command
 
+        provides :service, os: "!windows"
+
         def initialize(new_resource, run_context)
           super
           @init_command = "/etc/init.d/#{@new_resource.service_name}"

data/lib/chef/provider/service/insserv.rb

@@ -17,32 +17,39 @@
 #
 
 require 'chef/provider/service/init'
+require 'chef/util/path_helper'
 
 class Chef
   class Provider
     class Service
       class Insserv < Chef::Provider::Service::Init
 
+        provides :service, os: "linux"
+
+        def self.supports?(resource, action)
+          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:insserv)
+        end
+
         def load_current_resource
           super
 
-          # Look for a /etc/rc.*/SnnSERVICE link to signifiy that the service would be started in a runlevel
-          if Dir.glob("/etc/rc**/S*#{@current_resource.service_name}").empty?
-            @current_resource.enabled false
+          # Look for a /etc/rc.*/SnnSERVICE link to signify that the service would be started in a runlevel
+          if Dir.glob("/etc/rc**/S*#{Chef::Util::PathHelper.escape_glob(current_resource.service_name)}").empty?
+            current_resource.enabled false
           else
-            @current_resource.enabled true
+            current_resource.enabled true
           end
 
-          @current_resource
+          current_resource
         end
 
         def enable_service()
-          shell_out!("/sbin/insserv -r -f #{@new_resource.service_name}")
-          shell_out!("/sbin/insserv -d -f #{@new_resource.service_name}")
+          shell_out!("/sbin/insserv -r -f #{new_resource.service_name}")
+          shell_out!("/sbin/insserv -d -f #{new_resource.service_name}")
         end
 
         def disable_service()
-          shell_out!("/sbin/insserv -r -f #{@new_resource.service_name}")
+          shell_out!("/sbin/insserv -r -f #{new_resource.service_name}")
         end
       end
     end

data/lib/chef/provider/service/invokercd.rb

@@ -23,6 +23,12 @@ class Chef
     class Service
       class Invokercd < Chef::Provider::Service::Init
 
+        provides :service, platform_family: "debian"
+
+        def self.supports?(resource, action)
+          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:invokerc)
+        end
+
         def initialize(new_resource, run_context)
           super
           @init_command = "/usr/sbin/invoke-rc.d #{@new_resource.service_name}"

data/lib/chef/provider/service/macosx.rb

@@ -19,12 +19,15 @@
 require 'rexml/document'
 require 'chef/resource/service'
 require 'chef/provider/service/simple'
+require 'chef/util/path_helper'
 
 class Chef
   class Provider
     class Service
       class Macosx < Chef::Provider::Service::Simple
 
+        provides :service, os: "darwin"
+
         def self.gather_plist_dirs
           locations = %w{/Library/LaunchAgents
                          /Library/LaunchDaemons
@@ -194,7 +197,7 @@ class Chef
           plists = PLIST_DIRS.inject([]) do |results, dir|
             edir = ::File.expand_path(dir)
             entries = Dir.glob(
-              "#{edir}/*#{@current_resource.service_name}*.plist"
+              "#{edir}/*#{Chef::Util::PathHelper.escape_glob(@current_resource.service_name)}*.plist"
             )
             entries.any? ? results << entries : results
           end

data/lib/chef/provider/service/redhat.rb

@@ -26,11 +26,17 @@ class Chef
         CHKCONFIG_ON = /\d:on/
         CHKCONFIG_MISSING = /No such/
 
+        provides :service, platform_family: [ "rhel", "fedora", "suse" ]
+
+        def self.supports?(resource, action)
+          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:redhat)
+        end
+
         def initialize(new_resource, run_context)
           super
-           @init_command = "/sbin/service #{@new_resource.service_name}"
-           @new_resource.supports[:status] = true
-           @service_missing = false
+          @init_command = "/sbin/service #{@new_resource.service_name}"
+          @new_resource.supports[:status] = true
+          @service_missing = false
         end
 
         def define_resource_requirements

data/lib/chef/provider/service/simple.rb

@@ -25,6 +25,8 @@ class Chef
     class Service
       class Simple < Chef::Provider::Service
 
+        # this must be subclassed to be useful so does not directly implement :service
+
         attr_reader :status_load_success
 
         def load_current_resource

data/lib/chef/provider/service/solaris.rb

@@ -26,6 +26,8 @@ class Chef
       class Solaris < Chef::Provider::Service
         attr_reader :maintenance
 
+        provides :service, os: "solaris2"
+
         def initialize(new_resource, run_context=nil)
           super
           @init_command = "/usr/sbin/svcadm"

data/lib/chef/provider/service/systemd.rb

@@ -20,6 +20,13 @@ require 'chef/resource/service'
 require 'chef/provider/service/simple'
 
 class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
+
+  provides :service, os: "linux"
+
+  def self.supports?(resource, action)
+    Chef::Platform::ServiceHelpers.service_resource_providers.include?(:systemd)
+  end
+
   def load_current_resource
     @current_resource = Chef::Resource::Service.new(@new_resource.name)
     @current_resource.service_name(@new_resource.service_name)

data/lib/chef/provider/service/upstart.rb

@@ -27,6 +27,13 @@ class Chef
       class Upstart < Chef::Provider::Service::Simple
         UPSTART_STATE_FORMAT = /\w+ \(?(\w+)\)?[\/ ](\w+)/
 
+        provides :service, os: "linux"
+
+        def self.supports?(resource, action)
+          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:upstart) &&
+            Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:upstart)
+        end
+
         # Upstart does more than start or stop a service, creating multiple 'states' [1] that a service can be in.
         # In chef, when we ask a service to start, we expect it to have started before performing the next step
         # since we have top down dependencies. Which is to say we may follow witha resource next that requires

data/lib/chef/provider/service/windows.rb

@@ -25,6 +25,11 @@ end
 
 class Chef::Provider::Service::Windows < Chef::Provider::Service
 
+  provides :service, os: "windows"
+  provides :windows_service, os: "windows"
+
+  include Chef::Mixin::ShellOut
+
   #Win32::Service.get_start_type
   AUTO_START = 'auto start'
   MANUAL = 'demand start'

data/lib/chef/provider/subversion.rb

@@ -27,6 +27,8 @@ class Chef
   class Provider
     class Subversion < Chef::Provider
 
+      provides :subversion
+
       SVN_INFO_PATTERN = /^([\w\s]+): (.+)$/
 
       include Chef::Mixin::Command

data/lib/chef/provider/template.rb

@@ -25,6 +25,7 @@ require 'chef/deprecation/warnings'
 class Chef
   class Provider
     class Template < Chef::Provider::File
+      provides :template
 
       extend Chef::Deprecation::Warnings
       include Chef::Deprecation::Provider::Template

data/lib/chef/provider/user/dscl.rb

@@ -20,6 +20,7 @@ require 'mixlib/shellout'
 require 'chef/provider/user'
 require 'openssl'
 require 'plist'
+require 'chef/util/path_helper'
 
 class Chef
   class Provider
@@ -308,7 +309,7 @@ user password using shadow hash.")
 
           src = @current_resource.home
           FileUtils.mkdir_p(@new_resource.home)
-          files = ::Dir.glob("#{src}/*", ::File::FNM_DOTMATCH) - ["#{src}/.","#{src}/.."]
+          files = ::Dir.glob("#{Chef::Util::PathHelper.escape_glob(src)}/*", ::File::FNM_DOTMATCH) - ["#{src}/.","#{src}/.."]
           ::FileUtils.mv(files,@new_resource.home, :force => true)
           ::FileUtils.rmdir(src)
           ::FileUtils.chown_R(@new_resource.username,@new_resource.gid.to_s,@new_resource.home)
@@ -555,7 +556,7 @@ user password using shadow hash.")
           user_info = nil
 
           # We flush the cache here in order to make sure that we read fresh information
-          # for the user. 
+          # for the user.
           shell_out("dscacheutil '-flushcache'")
 
           begin

data/lib/chef/provider/whyrun_safe_ruby_block.rb

@@ -19,6 +19,8 @@
 class Chef
   class Provider
     class WhyrunSafeRubyBlock < Chef::Provider::RubyBlock
+      provides :whyrun_safe_ruby_block
+
       def action_run
         @new_resource.block.call
         @new_resource.updated_by_last_action(true)

data/lib/chef/provider_resolver.rb

@@ -0,0 +1,103 @@
+#
+# Author:: Richard Manyanza (<liseki@nyikacraftsmen.com>)
+# Copyright:: Copyright (c) 2014 Richard Manyanza.
+# 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.
+#
+
+require 'chef/exceptions'
+require 'chef/platform/provider_priority_map'
+
+class Chef
+  class ProviderResolver
+
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    # return a deterministically sorted list of Chef::Provider subclasses
+    def providers
+      Chef::Provider.descendants.sort {|a,b| a.to_s <=> b.to_s }
+    end
+
+    def resolve(resource, action)
+      maybe_explicit_provider(resource) ||
+        maybe_dynamic_provider_resolution(resource, action) ||
+        maybe_chef_platform_lookup(resource)
+    end
+
+    private
+
+    # if resource.provider is set, just return one of those objects
+    def maybe_explicit_provider(resource)
+      return nil unless resource.provider
+      resource.provider
+    end
+
+    # try dynamically finding a provider based on querying the providers to see what they support
+    def maybe_dynamic_provider_resolution(resource, action)
+      # this cut only depends on the node value and is going to be static for all nodes
+      # will contain all providers that could possibly support a resource on a node
+      enabled_handlers = providers.select do |klass|
+        klass.provides?(node, resource)
+      end
+
+      # log this so we know what providers will work for the generic resource on the node (early cut)
+      Chef::Log.debug "providers for generic #{resource.resource_name} resource enabled on node include: #{enabled_handlers}"
+
+      # ask all the enabled providers if they can actually support the resource
+      supported_handlers = enabled_handlers.select do |klass|
+        klass.supports?(resource, action)
+      end
+
+      # what providers were excluded by machine state (late cut)
+      Chef::Log.debug "providers that refused resource #{resource} were: #{enabled_handlers - supported_handlers}"
+      Chef::Log.debug "providers that support resource #{resource} include: #{supported_handlers}"
+
+      handlers = supported_handlers.empty? ? enabled_handlers : supported_handlers
+
+      if handlers.count >= 2
+        priority_list = [ get_provider_priority_map(resource.resource_name, node) ].flatten.compact
+
+        handlers = handlers.sort_by { |x| i = priority_list.index x; i.nil? ? Float::INFINITY : i }
+
+        handlers = [ handlers.first ]
+      end
+
+      Chef::Log.debug "providers that survived replacement include: #{handlers}"
+
+      raise Chef::Exceptions::AmbiguousProviderResolution.new(resource, handlers) if handlers.count >= 2
+
+      return nil if handlers.empty?
+
+      handlers[0]
+    end
+
+    # try the old static lookup of providers by platform
+    def maybe_chef_platform_lookup(resource)
+      Chef::Platform.find_provider_for_node(node, resource)
+    end
+
+    # dep injection hooks
+    def get_provider_priority_map(resource_name, node)
+      provider_priority_map.get(node, resource_name)
+    end
+
+    def provider_priority_map
+      Chef::Platform::ProviderPriorityMap.instance.priority_map
+    end
+  end
+end

data/lib/chef/providers.rb

@@ -24,6 +24,7 @@ require 'chef/provider/cron/solaris'
 require 'chef/provider/cron/aix'
 require 'chef/provider/deploy'
 require 'chef/provider/directory'
+require 'chef/provider/dsc_script'
 require 'chef/provider/env'
 require 'chef/provider/erl_call'
 require 'chef/provider/execute'
@@ -59,6 +60,7 @@ require 'chef/provider/package/easy_install'
 require 'chef/provider/package/freebsd/port'
 require 'chef/provider/package/freebsd/pkg'
 require 'chef/provider/package/freebsd/pkgng'
+require 'chef/provider/package/homebrew'
 require 'chef/provider/package/ips'
 require 'chef/provider/package/macports'
 require 'chef/provider/package/pacman'
@@ -73,19 +75,21 @@ require 'chef/provider/package/smartos'
 require 'chef/provider/package/aix'
 
 require 'chef/provider/service/arch'
-require 'chef/provider/service/debian'
 require 'chef/provider/service/freebsd'
 require 'chef/provider/service/gentoo'
 require 'chef/provider/service/init'
-require 'chef/provider/service/insserv'
 require 'chef/provider/service/invokercd'
+require 'chef/provider/service/debian'
 require 'chef/provider/service/redhat'
+require 'chef/provider/service/insserv'
 require 'chef/provider/service/simple'
 require 'chef/provider/service/systemd'
 require 'chef/provider/service/upstart'
 require 'chef/provider/service/windows'
 require 'chef/provider/service/solaris'
 require 'chef/provider/service/macosx'
+require 'chef/provider/service/aixinit'
+require 'chef/provider/service/aix'
 
 require 'chef/provider/user/dscl'
 require 'chef/provider/user/pw'

data/lib/chef/recipe.rb

@@ -96,6 +96,8 @@ class Chef
     # true<TrueClass>:: If all the parameters are present
     # false<FalseClass>:: If any of the parameters are missing
     def tagged?(*tags)
+      return false if run_context.node[:tags].nil?
+
       tags.each do |tag|
         return false unless run_context.node[:tags].include?(tag)
       end

data/lib/chef/resource.rb

@@ -27,11 +27,12 @@ require 'chef/guard_interpreter/resource_guard_interpreter'
 require 'chef/resource/conditional'
 require 'chef/resource/conditional_action_not_nothing'
 require 'chef/resource_collection'
-require 'chef/resource_platform_map'
+require 'chef/node_map'
 require 'chef/node'
 require 'chef/platform'
 
 require 'chef/mixin/deprecation'
+require 'chef/mixin/descendants_tracker'
 
 class Chef
   class Resource
@@ -133,6 +134,7 @@ F
     include Chef::Mixin::Deprecation
 
     extend Chef::Mixin::ConvertToClassName
+    extend Chef::Mixin::DescendantsTracker
 
     if Module.method(:const_defined?).arity == 1
       def self.strict_const_defined?(const)
@@ -144,24 +146,13 @@ F
       end
     end
 
-    # Track all subclasses of Resource. This is used so names can be looked up
-    # when attempting to deserialize from JSON. (See: json_compat)
-    def self.resource_classes
-      # Using a class variable here ensures we have one variable to track
-      # subclasses shared by the entire class hierarchy; without this, each
-      # subclass would have its own list of subclasses.
-      @@resource_classes ||= []
-    end
-
-    # Callback when subclass is defined. Adds subclass to list of subclasses.
-    def self.inherited(subclass)
-      resource_classes << subclass
-    end
-
-    # Look up a subclass by +class_name+ which should be a string that matches
-    # `Subclass.name`
-    def self.find_subclass_by_name(class_name)
-      resource_classes.first {|c| c.name == class_name }
+    class << self
+      # back-compat
+      # NOTE: that we do not support unregistering classes as descendents like
+      # we used to for LWRP unloading because that was horrible and removed in
+      # Chef-12.
+      alias :resource_classes :descendants
+      alias :find_subclass_by_name :find_descendants_by_name
     end
 
     # Set or return the list of "state attributes" implemented by the Resource
@@ -229,6 +220,8 @@ F
 
     attr_reader :elapsed_time
 
+    attr_reader :default_guard_interpreter
+
     # Each notify entry is a resource/action pair, modeled as an
     # Struct with a #resource and #action member
 
@@ -250,7 +243,13 @@ F
       @not_if = []
       @only_if = []
       @source_line = nil
-      @guard_interpreter = :default
+      # We would like to raise an error when the user gives us a guard
+      # interpreter and a ruby_block to the guard. In order to achieve this
+      # we need to understand when the user overrides the default guard
+      # interpreter. Therefore we store the default separately in a different
+      # attribute.
+      @guard_interpreter = nil
+      @default_guard_interpreter = :default
       @elapsed_time = 0
       @sensitive = false
     end
@@ -297,12 +296,13 @@ F
       end
     end
 
-    def load_prior_resource
+    def load_prior_resource(resource_type, instance_name)
       begin
-        prior_resource = run_context.resource_collection.lookup(self.to_s)
+        key = ::Chef::ResourceCollection::ResourceSet.create_key(resource_type, instance_name)
+        prior_resource = run_context.resource_collection.lookup(key)
         # if we get here, there is a prior resource (otherwise we'd have jumped
         # to the rescue clause).
-        Chef::Log.warn("Cloning resource attributes for #{self.to_s} from prior resource (CHEF-3694)")
+        Chef::Log.warn("Cloning resource attributes for #{key} from prior resource (CHEF-3694)")
         Chef::Log.warn("Previous #{prior_resource}: #{prior_resource.source_line}") if prior_resource.source_line
         Chef::Log.warn("Current  #{self}: #{self.source_line}") if self.source_line
         prior_resource.instance_variables.each do |iv|
@@ -410,11 +410,15 @@ F
     end
 
     def guard_interpreter(arg=nil)
-      set_or_return(
-        :guard_interpreter,
-        arg,
-        :kind_of => Symbol
-      )
+      if arg.nil?
+        @guard_interpreter || @default_guard_interpreter
+      else
+        set_or_return(
+          :guard_interpreter,
+          arg,
+          :kind_of => Symbol
+        )
+      end
     end
 
     # Sets up a notification from this resource to the resource specified by +resource_spec+.
@@ -639,6 +643,11 @@ F
       # on accident
       updated_by_last_action(false)
 
+      # Don't modify @retries directly and keep it intact, so that the
+      # recipe_snippet from ResourceFailureInspector can print the value
+      # that was set in the resource block initially.
+      remaining_retries = retries
+
       begin
         return if should_skip?(action)
         provider_for_action(action).run_action
@@ -646,10 +655,10 @@ F
         if ignore_failure
           Chef::Log.error("#{custom_exception_message(e)}; ignore_failure is set, continuing")
           events.resource_failed(self, action, e)
-        elsif retries > 0
-          events.resource_failed_retriable(self, action, retries, e)
-          @retries -= 1
-          Chef::Log.info("Retrying execution of #{self}, #{retries} attempt(s) left")
+        elsif remaining_retries > 0
+          events.resource_failed_retriable(self, action, remaining_retries, e)
+          remaining_retries -= 1
+          Chef::Log.info("Retrying execution of #{self}, #{remaining_retries} attempt(s) left")
           sleep retry_delay
           retry
         else
@@ -670,16 +679,9 @@ F
     end
 
     def provider_for_action(action)
-      # leverage new platform => short_name => resource
-      # which requires explicitly setting provider in
-      # resource class
-      if self.provider
-        provider = self.provider.new(self, self.run_context)
-        provider.action = action
-        provider
-      else # fall back to old provider resolution
-        Chef::Platform.provider_for_resource(self, action)
-      end
+      provider = run_context.provider_resolver.resolve(self, action).new(self, run_context)
+      provider.action = action
+      provider
     end
 
     def custom_exception_message(e)
@@ -754,8 +756,8 @@ F
       @provider_base ||= Chef::Provider
     end
 
-    def self.platform_map
-      @@platform_map ||= PlatformMap.new
+    def self.node_map
+      @@node_map ||= NodeMap.new
     end
 
     # Maps a short_name (and optionally a platform  and version) to a
@@ -764,66 +766,55 @@ F
     # (I'm looking at you Chef::Resource::Package)
     # Ex:
     #   class WindowsFile < Chef::Resource
-    #     provides :file, :on_platforms => ["windows"]
+    #     provides :file, os: "linux", platform_family: "rhel", platform: "redhat"
+    #     provides :file, os: "!windows
+    #     provides :file, os: [ "linux", "aix" ]
+    #     provides :file, os: "solaris2" do |node|
+    #       node['platform_version'].to_f <= 5.11
+    #     end
     #     # ...other stuff
     #   end
     #
-    # TODO: 2011-11-02 schisamo - platform_version support
-    def self.provides(short_name, opts={})
+    def self.provides(short_name, opts={}, &block)
       short_name_sym = short_name
       if short_name.kind_of?(String)
+        # YAGNI: this is probably completely unnecessary and can be removed?
+        Chef::Log.warn "[DEPRECATION] Passing a String to Chef::Resource#provides will be removed"
         short_name.downcase!
         short_name.gsub!(/\s/, "_")
         short_name_sym = short_name.to_sym
       end
-      if opts.has_key?(:on_platforms)
-        platforms = [opts[:on_platforms]].flatten
-        platforms.each do |p|
-          p = :default if :all == p.to_sym
-          platform_map.set(
-            :platform => p.to_sym,
-            :short_name => short_name_sym,
-            :resource => self
-          )
-        end
-      else
-        platform_map.set(
-          :short_name => short_name_sym,
-          :resource => self
-        )
-      end
+      node_map.set(short_name_sym, constantize(self.name), opts, &block)
     end
 
-    # Returns a resource based on a short_name anda platform and version.
-    #
+    # Returns a resource based on a short_name and node
     #
     # ==== Parameters
     # short_name<Symbol>:: short_name of the resource (ie :directory)
-    # platform<Symbol,String>:: platform name
-    # version<String>:: platform version
+    # node<Chef::Node>:: Node object to look up platform and version in
     #
     # === Returns
     # <Chef::Resource>:: returns the proper Chef::Resource class
-    def self.resource_for_platform(short_name, platform=nil, version=nil)
-      platform_map.get(short_name, platform, version)
+    def self.resource_for_node(short_name, node)
+      klass = node_map.get(node, short_name) ||
+        resource_matching_short_name(short_name)
+      raise Chef::Exceptions::NoSuchResourceType.new(short_name, node) if klass.nil?
+      klass
     end
 
-    # Returns a resource based on a short_name and a node's
-    # platform and version.
-    #
+    # Returns the class of a Chef::Resource based on the short name
     # ==== Parameters
     # short_name<Symbol>:: short_name of the resource (ie :directory)
-    # node<Chef::Node>:: Node object to look up platform and version in
     #
     # === Returns
     # <Chef::Resource>:: returns the proper Chef::Resource class
-    def self.resource_for_node(short_name, node)
+    def self.resource_matching_short_name(short_name)
       begin
-        platform, version = Chef::Platform.find_platform_and_version(node)
-      rescue ArgumentError
+        rname = convert_to_class_name(short_name.to_s)
+        Chef::Resource.const_get(rname)
+      rescue NameError
+        nil
       end
-      resource = resource_for_platform(short_name, platform, version)
-      resource
     end
 
     private