chef 12.4.0 → 12.4.1

data/lib/chef/provider/package/aix.rb

@@ -26,6 +26,7 @@ class Chef
     class Package
       class Aix < Chef::Provider::Package
 
+        provides :package, os: "aix"
         provides :bff_package, os: "aix"
 
         include Chef::Mixin::GetSourceFromPackage

data/lib/chef/provider/package/apt.rb

@@ -25,6 +25,7 @@ class Chef
     class Package
       class Apt < Chef::Provider::Package
 
+        provides :package, platform_family: "debian"
         provides :apt_package, os: "linux"
 
         # return [Hash] mapping of package name to Boolean value

data/lib/chef/provider/package/homebrew.rb

@@ -26,6 +26,7 @@ class Chef
     class Package
       class Homebrew < Chef::Provider::Package
 
+        provides :package, os: "darwin", override: true
         provides :homebrew_package
 
         include Chef::Mixin::HomebrewUser

data/lib/chef/provider/package/ips.rb

@@ -27,6 +27,7 @@ class Chef
     class Package
       class Ips < Chef::Provider::Package
 
+        provides :package, platform: %w(openindiana opensolaris omnios solaris2)
         provides :ips_package, os: "solaris2"
 
         attr_accessor :virtual

data/lib/chef/provider/package/macports.rb

@@ -3,6 +3,7 @@ class Chef
     class Package
       class Macports < Chef::Provider::Package
 
+        provides :package, os: "darwin"
         provides :macports_package
 
         def load_current_resource

data/lib/chef/provider/package/openbsd.rb

@@ -31,6 +31,7 @@ class Chef
       class Openbsd < Chef::Provider::Package
 
         provides :package, os: "openbsd"
+        provides :openbsd_package
 
         include Chef::Mixin::ShellOut
         include Chef::Mixin::GetSourceFromPackage

data/lib/chef/provider/package/pacman.rb

@@ -25,6 +25,7 @@ class Chef
     class Package
       class Pacman < Chef::Provider::Package
 
+        provides :package, platform: "arch"
         provides :pacman_package, os: "linux"
 
         def load_current_resource

data/lib/chef/provider/package/paludis.rb

@@ -24,6 +24,7 @@ class Chef
     class Package
       class Paludis < Chef::Provider::Package
 
+        provides :package, platform: "exherbo"
         provides :paludis_package, os: "linux"
 
         def load_current_resource

data/lib/chef/provider/package/portage.rb

@@ -25,6 +25,8 @@ class Chef
   class Provider
     class Package
       class Portage < Chef::Provider::Package
+
+        provides :package, platform: "gentoo"
         provides :portage_package
 
         PACKAGE_NAME_PATTERN = %r{(?:([^/]+)/)?([^/]+)}

data/lib/chef/provider/package/smartos.rb

@@ -29,6 +29,7 @@ class Chef
       class SmartOS < Chef::Provider::Package
         attr_accessor :is_virtual_package
 
+        provides :package, platform: "smartos"
         provides :smartos_package, os: "solaris2", platform_family: "smartos"
 
         def load_current_resource

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

@@ -27,6 +27,8 @@ class Chef
 
         include Chef::Mixin::GetSourceFromPackage
 
+        provides :package, platform: "nexentacore"
+        provides :package, platform: "solaris2", platform_version: '< 5.11'
         provides :solaris_package, os: "solaris2"
 
         # def initialize(*args)

data/lib/chef/provider/package/yum.rb

@@ -28,6 +28,7 @@ class Chef
     class Package
       class Yum < Chef::Provider::Package
 
+        provides :package, platform_family: %w(rhel fedora)
         provides :yum_package, os: "linux"
 
         class RPMUtils

data/lib/chef/provider/package/zypper.rb

@@ -29,6 +29,7 @@ class Chef
     class Package
       class Zypper < Chef::Provider::Package
 
+        provides :package, platform_family: "suse"
         provides :zypper_package, os: "linux"
 
         def load_current_resource

data/lib/chef/provider/service.rb

@@ -188,29 +188,11 @@ class Chef
         require 'chef/provider/service/upstart'
         require 'chef/provider/service/debian'
         require 'chef/provider/service/invokercd'
-        require 'chef/provider/service/freebsd'
-        require 'chef/provider/service/openbsd'
-        require 'chef/provider/service/solaris'
-        require 'chef/provider/service/macosx'
-
-        def self.os(os, *providers)
-          Chef.set_provider_priority_array(:service, providers, os: os)
-        end
-        def self.platform_family(platform_family, *providers)
-          Chef.set_provider_priority_array(:service, providers, platform_family: platform_family)
-        end
-
-        os %w(freebsd netbsd), Freebsd
-        os %w(openbsd),        Openbsd
-        os %w(solaris2),       Solaris
-        os %w(darwin),         Macosx
-        os %w(linux),          Systemd, Insserv, Redhat
-
-        platform_family %w(arch),             Systemd, Arch
-        platform_family %w(gentoo),           Systemd, Gentoo
-        platform_family %w(debian),           Systemd, Upstart, Insserv, Debian, Invokercd
-        platform_family %w(rhel fedora suse), Systemd, Insserv, Redhat
 
+        Chef.set_provider_priority_array :service, [ Systemd, Arch ], platform_family: 'arch'
+        Chef.set_provider_priority_array :service, [ Systemd, Gentoo ], platform_family: 'gentoo'
+        Chef.set_provider_priority_array :service, [ Systemd, Upstart, Insserv, Debian, Invokercd ], platform_family: 'debian'
+        Chef.set_provider_priority_array :service, [ Systemd, Insserv, Redhat ], platform_family: %w(rhel fedora suse)
       end
     end
   end

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

@@ -22,6 +22,8 @@ class Chef
   class Provider
     class Service
       class Debian < Chef::Provider::Service::Init
+        provides :service, platform_family: 'debian'
+
         UPDATE_RC_D_ENABLED_MATCHES = /\/rc[\dS].d\/S|not installed/i
         UPDATE_RC_D_PRIORITIES = /\/rc([\dS]).d\/([SK])(\d\d)/i
 

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

@@ -24,6 +24,8 @@ class Chef
     class Service
       class Insserv < Chef::Provider::Service::Init
 
+        provides :service, platform_family: %w(debian rhel fedora suse)
+
         def self.provides?(node, resource)
           super && Chef::Platform::ServiceHelpers.service_resource_providers.include?(:insserv)
         end

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

@@ -23,6 +23,8 @@ class Chef
     class Service
       class Invokercd < Chef::Provider::Service::Init
 
+        provides :service, platform_family: 'debian', override: true
+
         def self.provides?(node, resource)
           super && Chef::Platform::ServiceHelpers.service_resource_providers.include?(:invokercd)
         end

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

@@ -26,7 +26,7 @@ class Chef
     class Service
       class Openbsd < Chef::Provider::Service::Init
 
-        provides :service, os: [ "openbsd" ]
+        provides :service, os: "openbsd"
 
         include Chef::Mixin::ShellOut
 

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

@@ -23,6 +23,8 @@ class Chef
     class Service
       class Redhat < Chef::Provider::Service::Init
 
+        provides :service, platform_family: %w(rhel fedora suse)
+
         CHKCONFIG_ON = /\d:on/
         CHKCONFIG_MISSING = /No such/
 

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

@@ -25,6 +25,9 @@ class Chef
   class Provider
     class Service
       class Upstart < Chef::Provider::Service::Simple
+
+        provides :service, platform_family: 'debian', override: true
+
         UPSTART_STATE_FORMAT = /\w+ \(?(\w+)\)?[\/ ](\w+)/
 
         def self.provides?(node, resource)

data/lib/chef/provider_resolver.rb

@@ -17,7 +17,7 @@
 #
 
 require 'chef/exceptions'
-require 'chef/platform/provider_priority_map'
+require 'chef/platform/priority_map'
 
 class Chef
   #
@@ -62,12 +62,47 @@ class Chef
         maybe_chef_platform_lookup(resource)
     end
 
+    # Does NOT call provides? on the resource (it is assumed this is being
+    # called *from* provides?).
     def provided_by?(provider_class)
-      prioritized_handlers.include?(provider_class)
+      potential_handlers.include?(provider_class)
+    end
+
+    def enabled_handlers
+      @enabled_handlers ||= potential_handlers.select { |handler| !overrode_provides?(handler) || handler.provides?(node, resource) }
+    end
+
+    # TODO deprecate this and allow actions to be passed as a filter to
+    # `provides` so we don't have to have two separate things.
+    # @api private
+    def supported_handlers
+      enabled_handlers.select { |handler| handler.supports?(resource, action) }
     end
 
     private
 
+    def potential_handlers
+      handler_map.list(node, resource.resource_name).uniq
+    end
+
+    # The list of handlers, with any in the priority_map moved to the front
+    def prioritized_handlers
+      @prioritized_handlers ||= begin
+        supported_handlers = self.supported_handlers
+        if supported_handlers.empty?
+          # if none of the providers specifically support the resource, we still need to pick one of the providers that are
+          # enabled on the node to handle the why-run use case. FIXME we should only do this in why-run mode then.
+          Chef::Log.debug "No providers responded true to `supports?` for action #{action} on resource #{resource}, falling back to enabled handlers so we can return something anyway."
+          supported_handlers = enabled_handlers
+        end
+
+        prioritized = priority_map.list(node, resource.resource_name).flatten(1)
+        prioritized &= supported_handlers # Filter the priority map by the actual enabled handlers
+        prioritized |= supported_handlers # Bring back any handlers that aren't in the priority map, at the *end* (ordered set)
+        prioritized
+      end
+    end
+
     # if resource.provider is set, just return one of those objects
     def maybe_explicit_provider(resource)
       return nil unless resource.provider
@@ -78,27 +113,7 @@ class Chef
     def maybe_dynamic_provider_resolution(resource, action)
       Chef::Log.debug "Providers for generic #{resource.resource_name} resource enabled on node include: #{enabled_handlers}"
 
-      # Get all the handlers in the priority bucket
-      handlers = prioritized_handlers
-
-      # Narrow it down to handlers that return `true` to `provides?`
-      # TODO deprecate this and don't bother calling--the fact that they said
-      # `provides` should be enough.  But we need to do it right now because
-      # some classes implement additional handling.
-      enabled_handlers = prioritized_handlers.select { |handler| handler.provides?(node, resource) }
-
-      # Narrow it down to handlers that return `true` to `supports?`
-      # TODO deprecate this and allow actions to be passed as a filter to
-      # `provides` so we don't have to have two separate things.
-      supported_handlers = enabled_handlers.select { |handler| handler.supports?(resource, action) }
-      if supported_handlers.empty?
-        # if none of the providers specifically support the resource, we still need to pick one of the providers that are
-        # enabled on the node to handle the why-run use case. FIXME we should only do this in why-run mode then.
-        Chef::Log.debug "No providers responded true to `supports?` for action #{action} on resource #{resource}, falling back to enabled handlers so we can return something anyway."
-        handler = enabled_handlers.first
-      else
-        handler = supported_handlers.first
-      end
+      handler = prioritized_handlers.first
 
       if handler
         Chef::Log.debug "Provider for action #{action} on resource #{resource} is #{handler}"
@@ -114,13 +129,16 @@ class Chef
       Chef::Platform.find_provider_for_node(node, resource)
     end
 
-    def provider_priority_map
-      Chef::Platform::ProviderPriorityMap.instance
+    def priority_map
+      Chef.provider_priority_map
     end
 
-    def prioritized_handlers
-      @prioritized_handlers ||=
-        provider_priority_map.list_handlers(node, resource.resource_name).flatten(1).uniq
+    def handler_map
+      Chef.provider_handler_map
+    end
+
+    def overrode_provides?(handler)
+      handler.method(:provides?).owner != Chef::Provider.method(:provides?).owner
     end
 
     module Deprecated
@@ -129,33 +147,21 @@ class Chef
         @providers ||= Chef::Provider.descendants
       end
 
-      # this cut looks at if the provider can handle the resource type on the node
       def enabled_handlers
-        @enabled_handlers ||=
-          providers.select do |klass|
-            # NB: this is different from resource_resolver which must pass a resource_name
-            # FIXME: deprecate this and normalize on passing resource_name here
-            klass.provides?(node, resource)
-          end.sort {|a,b| a.to_s <=> b.to_s }
-      end
-
-      # this cut looks at if the provider can handle the specific resource and action
-      def supported_handlers
-        @supported_handlers ||=
-          enabled_handlers.select do |klass|
-            klass.supports?(resource, action)
-          end
-      end
-
-      # If there are no providers for a DSL, we search through the
-      def prioritized_handlers
-        @prioritized_handlers ||= super || begin
-          result = providers.select { |handler| handler.provides?(node, resource) }.sort_by(:name)
-          if !result.empty?
-            Chef::Log.deprecation("#{resource.resource_name.to_sym} is marked as providing DSL #{method_symbol}, but provides #{resource.resource_name.to_sym.inspect} was never called!")
-            Chef::Log.deprecation("In Chef 13, this will break: you must call provides to mark the names you provide, even if you also override provides? yourself.")
+        @enabled_handlers ||= begin
+          handlers = super
+          if handlers.empty?
+            # Look through all providers, and find ones that return true to provides.
+            # Don't bother with ones that don't override provides?, since they
+            # would have been in enabled_handlers already if that were so. (It's a
+            # perf concern otherwise.)
+            handlers = providers.select { |handler| overrode_provides?(handler) && handler.provides?(node, resource) }
+            handlers.each do |handler|
+              Chef::Log.deprecation("#{handler}.provides? returned true when asked if it provides DSL #{resource.resource_name}, but provides #{resource.resource_name.inspect} was never called!")
+              Chef::Log.deprecation("In Chef 13, this will break: you must call provides to mark the names you provide, even if you also override provides? yourself.")
+            end
           end
-          result
+          handlers
         end
       end
     end

data/lib/chef/resource.rb

@@ -171,27 +171,25 @@ class Chef
     # @param arg [Array[Symbol], Symbol] A list of actions (e.g. `:create`)
     # @return [Array[Symbol]] the list of actions.
     #
-    attr_accessor :action
     def action(arg=nil)
       if arg
-        if arg.is_a?(Array)
-          arg = arg.map { |a| a.to_sym }
-        else
-          arg = arg.to_sym
-        end
-        Array(arg).each do |action|
+        arg = Array(arg).map(&:to_sym)
+        arg.each do |action|
           validate(
             { action: action },
             { action: { kind_of: Symbol, equal_to: allowed_actions } }
           )
         end
-        self.action = arg
+        @action = arg
       else
         # Pull the action from the class if it's not set
         @action || self.class.default_action
       end
     end
 
+    # Alias for normal assigment syntax.
+    alias_method :action=, :action
+
     #
     # Sets up a notification that will run a particular action on another resource
     # if and when *this* resource is updated by an action.
@@ -917,7 +915,7 @@ class Chef
         if name
           name = name.to_sym
           # If our class is not already providing this name, provide it.
-          if !Chef::ResourceResolver.list(name).include?(self)
+          if !Chef::ResourceResolver.includes_handler?(name, self)
             provides name, canonical: true
           end
           @resource_name = name
@@ -981,22 +979,17 @@ class Chef
     # Setting default_action will automatially add the action to
     # allowed_actions, if it isn't already there.
     #
-    # Defaults to :nothing.
+    # Defaults to [:nothing].
     #
     # @param action_name [Symbol,Array<Symbol>] The default action (or series
     #   of actions) to use.
     #
-    # @return [Symbol,Array<Symbol>] The default actions for the resource.
+    # @return [Array<Symbol>] The default actions for the resource.
     #
     def self.default_action(action_name=NULL_ARG)
       unless action_name.equal?(NULL_ARG)
-        if action_name.is_a?(Array)
-          @default_action = action_name.map { |arg| arg.to_sym }
-        else
-          @default_action = action_name.to_sym
-        end
-
-        self.allowed_actions |= Array(@default_action)
+        @default_action = Array(action_name).map(&:to_sym)
+        self.allowed_actions |= @default_action
       end
 
       if @default_action
@@ -1004,13 +997,14 @@ class Chef
       elsif superclass.respond_to?(:default_action)
         superclass.default_action
       else
-        :nothing
+        [:nothing]
       end
     end
     def self.default_action=(action_name)
       default_action(action_name)
     end
 
+
     #
     # Internal Resource Interface (for Chef)
     #
@@ -1105,7 +1099,7 @@ class Chef
     end
     def self.inherited(child)
       super
-      @sorted_descendants = nil
+      @@sorted_descendants = nil
       # set resource_name automatically if it's not set
       if child.name && !child.resource_name
         if child.name =~ /^Chef::Resource::(\w+)$/
@@ -1143,13 +1137,13 @@ class Chef
         remove_canonical_dsl
       end
 
-      result = Chef.resource_priority_map.set(name, self, options, &block)
+      result = Chef.resource_handler_map.set(name, self, options, &block)
       Chef::DSL::Resources.add_resource_dsl(name)
       result
     end
 
-    def self.provides?(node, resource)
-      Chef::ResourceResolver.resolve(resource, node: node).provided_by?(self)
+    def self.provides?(node, resource_name)
+      Chef::ResourceResolver.new(node, resource_name).provided_by?(self)
     end
 
     # Helper for #notifies
@@ -1306,56 +1300,11 @@ class Chef
         Chef::Resource.send(:remove_const, class_name)
       end
 
-      # In order to generate deprecation warnings when you use Chef::Resource::MyLwrp,
-      # we make a special subclass (identical in nearly all respects) of the
-      # actual LWRP.  When you say any of these, a deprecation warning will be
-      # generated:
-      #
-      # - Chef::Resource::MyLwrp.new(...)
-      # - resource.is_a?(Chef::Resource::MyLwrp)
-      # - resource.kind_of?(Chef::Resource::MyLwrp)
-      # - case resource
-      #   when Chef::Resource::MyLwrp
-      #   end
-      #
-      resource_subclass = Class.new(resource_class) do
-        resource_name nil # we do not actually provide anything
-        def initialize(*args, &block)
-          Chef::Log.deprecation("Using an LWRP by its name (#{self.class.name}) directly is no longer supported in Chef 13 and will be removed.  Use Chef::Resource.resource_for_node(node, name) instead.")
-          super
-        end
-        def self.resource_name(*args)
-          if args.empty?
-            @resource_name ||= superclass.resource_name
-          else
-            super
-          end
-        end
-        self
-      end
-      eval("Chef::Resource::#{class_name} = resource_subclass")
-      # Make case, is_a and kind_of work with the new subclass, for backcompat.
-      # Any subclass of Chef::Resource::ResourceClass is already a subclass of resource_class
-      # Any subclass of resource_class is considered a subclass of Chef::Resource::ResourceClass
-      resource_class.class_eval do
-        define_method(:is_a?) do |other|
-          other.is_a?(Module) && other === self
-        end
-        define_method(:kind_of?) do |other|
-          other.is_a?(Module) && other === self
-        end
+      if !Chef::Config[:treat_deprecation_warnings_as_errors]
+        Chef::Resource.const_set(class_name, resource_class)
+        deprecated_constants[class_name.to_sym] = resource_class
       end
-      resource_subclass.class_eval do
-        define_singleton_method(:===) do |other|
-          Chef::Log.deprecation("Using an LWRP by its name (#{class_name}) directly is no longer supported in Chef 13 and will be removed.  Use Chef::Resource.resource_for_node(node, name) instead.")
-          # resource_subclass is a superclass of all resource_class descendants.
-          if self == resource_subclass && other.class <= resource_class
-            return true
-          end
-          super(other)
-        end
-      end
-      deprecated_constants[class_name.to_sym] = resource_subclass
+
     end
 
     def self.deprecated_constants
@@ -1379,7 +1328,7 @@ class Chef
 
     def self.remove_canonical_dsl
       if @resource_name
-        remaining = Chef.resource_priority_map.delete_canonical(@resource_name, self)
+        remaining = Chef.resource_handler_map.delete_canonical(@resource_name, self)
         if !remaining
           Chef::DSL::Resources.remove_resource_dsl(@resource_name)
         end