chef 12.22.1-universal-mingw32 → 12.22.3-universal-mingw32

data/lib/chef/provider.rb

@@ -1,458 +1,458 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Christopher Walters (<cw@chef.io>)
-# Copyright:: Copyright 2008-2016, 2009-2016 Chef Software, 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.
-#
-
-require "chef/mixin/from_file"
-require "chef/mixin/convert_to_class_name"
-require "chef/mixin/enforce_ownership_and_permissions"
-require "chef/mixin/why_run"
-require "chef/mixin/shell_out"
-require "chef/mixin/provides"
-require "chef/dsl/core"
-require "chef/platform/service_helpers"
-require "chef/node_map"
-require "forwardable"
-
-class Chef
-  class Provider
-    require "chef/mixin/why_run"
-    require "chef/mixin/provides"
-
-    attr_accessor :new_resource
-    attr_accessor :current_resource
-    attr_accessor :run_context
-
-    attr_reader :recipe_name
-    attr_reader :cookbook_name
-
-    include Chef::Mixin::WhyRun
-    extend Chef::Mixin::Provides
-
-    # includes the "core" DSL and not the "recipe" DSL by design
-    include Chef::DSL::Core
-
-    # supports the given resource and action (late binding)
-    def self.supports?(resource, action)
-      true
-    end
-
-    #--
-    # TODO: this should be a reader, and the action should be passed in the
-    # constructor; however, many/most subclasses override the constructor so
-    # changing the arity would be a breaking change. Change this at the next
-    # break, e.g., Chef 11.
-    attr_accessor :action
-
-    def initialize(new_resource, run_context)
-      @new_resource = new_resource
-      @action = action
-      @current_resource = nil
-      @run_context = run_context
-      @converge_actions = nil
-
-      @recipe_name = nil
-      @cookbook_name = nil
-      self.class.include_resource_dsl_module(new_resource)
-    end
-
-    def whyrun_mode?
-      Chef::Config[:why_run]
-    end
-
-    def whyrun_supported?
-      false
-    end
-
-    def node
-      run_context && run_context.node
-    end
-
-    # Used by providers supporting embedded recipes
-    def resource_collection
-      run_context && run_context.resource_collection
-    end
-
-    def cookbook_name
-      new_resource.cookbook_name
-    end
-
-    def check_resource_semantics!
-    end
-
-    def load_current_resource
-      raise Chef::Exceptions::Override, "You must override load_current_resource in #{self}"
-    end
-
-    def define_resource_requirements
-    end
-
-    def cleanup_after_converge
-    end
-
-    def action_nothing
-      Chef::Log.debug("Doing nothing for #{@new_resource}")
-      true
-    end
-
-    def events
-      run_context.events
-    end
-
-    def run_action(action = nil)
-      @action = action unless action.nil?
-
-      # TODO: it would be preferable to get the action to be executed in the
-      # constructor...
-
-      check_resource_semantics!
-
-      # user-defined LWRPs may include unsafe load_current_resource methods that cannot be run in whyrun mode
-      if whyrun_mode? && !whyrun_supported?
-        events.resource_current_state_load_bypassed(@new_resource, @action, @current_resource)
-      else
-        load_current_resource
-        events.resource_current_state_loaded(@new_resource, @action, @current_resource)
-      end
-
-      define_resource_requirements
-      process_resource_requirements
-
-      # user-defined providers including LWRPs may
-      # not include whyrun support - if they don't support it
-      # we can't execute any actions while we're running in
-      # whyrun mode. Instead we 'fake' whyrun by documenting that
-      # we can't execute the action.
-      # in non-whyrun mode, this will still cause the action to be
-      # executed normally.
-      if whyrun_mode? && (!whyrun_supported? || requirements.action_blocked?(@action))
-        events.resource_bypassed(@new_resource, @action, self)
-      else
-        send("action_#{@action}")
-      end
-
-      set_updated_status
-
-      cleanup_after_converge
-    end
-
-    def process_resource_requirements
-      requirements.run(:all_actions) unless @action == :nothing
-      requirements.run(@action)
-    end
-
-    def resource_updated?
-      !converge_actions.empty? || @new_resource.updated_by_last_action?
-    end
-
-    def set_updated_status
-      if !resource_updated?
-        events.resource_up_to_date(@new_resource, @action)
-      else
-        events.resource_updated(@new_resource, @action)
-        new_resource.updated_by_last_action(true)
-      end
-    end
-
-    def requirements
-      @requirements ||= ResourceRequirements.new(@new_resource, run_context)
-    end
-
-    def converge_by(descriptions, &block)
-      converge_actions.add_action(descriptions, &block)
-    end
-
-    #
-    # Handle patchy convergence safely.
-    #
-    # - Does *not* call the block if the current_resource's properties match
-    #   the properties the user specified on the resource.
-    # - Calls the block if current_resource does not exist
-    # - Calls the block if the user has specified any properties in the resource
-    #   whose values are *different* from current_resource.
-    # - Does *not* call the block if why-run is enabled (just prints out text).
-    # - Prints out automatic green text saying what properties have changed.
-    #
-    # @param properties An optional list of property names (symbols). If not
-    #   specified, `new_resource.class.state_properties` will be used.
-    # @param converge_block The block to do the converging in.
-    #
-    # @return [Boolean] whether the block was executed.
-    #
-    def converge_if_changed(*properties, &converge_block)
-      if !converge_block
-        raise ArgumentError, "converge_if_changed must be passed a block!"
-      end
-
-      properties = new_resource.class.state_properties.map { |p| p.name } if properties.empty?
-      properties = properties.map { |p| p.to_sym }
-      if current_resource
-        # Collect the list of modified properties
-        specified_properties = properties.select { |property| new_resource.property_is_set?(property) }
-        modified = specified_properties.select { |p| new_resource.send(p) != current_resource.send(p) }
-        if modified.empty?
-          properties_str = if new_resource.sensitive
-                             specified_properties.join(", ")
-                           else
-                             specified_properties.map { |p| "#{p}=#{new_resource.send(p).inspect}" }.join(", ")
-                           end
-          Chef::Log.debug("Skipping update of #{new_resource}: has not changed any of the specified properties #{properties_str}.")
-          return false
-        end
-
-        # Print the pretty green text and run the block
-        property_size = modified.map { |p| p.size }.max
-        modified.map! do |p|
-          properties_str = if new_resource.sensitive
-                             "(suppressed sensitive property)"
-                           else
-                             "#{new_resource.send(p).inspect} (was #{current_resource.send(p).inspect})"
-                           end
-          "  set #{p.to_s.ljust(property_size)} to #{properties_str}"
-        end
-        converge_by([ "update #{current_resource.identity}" ] + modified, &converge_block)
-
-      else
-        # The resource doesn't exist. Mark that we are *creating* this, and
-        # write down any properties we are setting.
-        property_size = properties.map { |p| p.size }.max
-        created = properties.map do |property|
-          default = " (default value)" unless new_resource.property_is_set?(property)
-          properties_str = if new_resource.sensitive
-                             "(suppressed sensitive property)"
-                           else
-                             new_resource.send(property).inspect
-                           end
-          "  set #{property.to_s.ljust(property_size)} to #{properties_str}#{default}"
-        end
-
-        converge_by([ "create #{new_resource.identity}" ] + created, &converge_block)
-      end
-      true
-    end
-
-    def self.provides(short_name, opts = {}, &block)
-      Chef.provider_handler_map.set(short_name, self, opts, &block)
-    end
-
-    def self.provides?(node, resource)
-      Chef::ProviderResolver.new(node, resource, :nothing).provided_by?(self)
-    end
-
-    #
-    # Include attributes, public and protected methods from this Resource in
-    # the provider.
-    #
-    # If this is set to true, delegate methods are included in the provider so
-    # that you can call (for example) `attrname` and it will call
-    # `new_resource.attrname`.
-    #
-    # The actual include does not happen until the first time the Provider
-    # is instantiated (so that we don't have to worry about load order issues).
-    #
-    # @param include_resource_dsl [Boolean] Whether to include resource DSL or
-    #   not (defaults to `false`).
-    #
-    def self.include_resource_dsl(include_resource_dsl)
-      @include_resource_dsl = include_resource_dsl
-    end
-
-    # Create the resource DSL module that forwards resource methods to new_resource
-    #
-    # @api private
-    def self.include_resource_dsl_module(resource)
-      if @include_resource_dsl && !defined?(@included_resource_dsl_module)
-        provider_class = self
-        @included_resource_dsl_module = Module.new do
-          extend Forwardable
-          define_singleton_method(:to_s) { "forwarder module for #{provider_class}" }
-          define_singleton_method(:inspect) { to_s }
-          # Add a delegator for each explicit property that will get the *current* value
-          # of the property by default instead of the *actual* value.
-          resource.class.properties.each do |name, property|
-            class_eval(<<-EOM, __FILE__, __LINE__)
-              def #{name}(*args, &block)
-                # If no arguments were passed, we process "get" by defaulting
-                # the value to current_resource, not new_resource. This helps
-                # avoid issues where resources accidentally overwrite perfectly
-                # valid stuff with default values.
-                if args.empty? && !block
-                  if !new_resource.property_is_set?(__method__) && current_resource
-                    return current_resource.public_send(__method__)
-                  end
-                end
-                new_resource.public_send(__method__, *args, &block)
-              end
-            EOM
-          end
-          dsl_methods =
-            resource.class.public_instance_methods +
-            resource.class.protected_instance_methods -
-            provider_class.instance_methods -
-            resource.class.properties.keys
-          def_delegators(:new_resource, *dsl_methods)
-        end
-        include @included_resource_dsl_module
-      end
-    end
-
-    # Enables inline evaluation of resources in provider actions.
-    #
-    # Without this option, any resources declared inside the Provider are added
-    # to the resource collection after the current position at the time the
-    # action is executed. Because they are added to the primary resource
-    # collection for the chef run, they can notify other resources outside
-    # the Provider, and potentially be notified by resources outside the Provider
-    # (but this is complicated by the fact that they don't exist until the
-    # provider executes). In this mode, it is impossible to correctly set the
-    # updated_by_last_action flag on the parent Provider resource, since it
-    # executes and returns before its component resources are run.
-    #
-    # With this option enabled, each action creates a temporary run_context
-    # with its own resource collection, evaluates the action's code in that
-    # context, and then converges the resources created. If any resources
-    # were updated, then this provider's new_resource will be marked updated.
-    #
-    # In this mode, resources created within the Provider cannot interact with
-    # external resources via notifies, though notifications to other
-    # resources within the Provider will work. Delayed notifications are executed
-    # at the conclusion of the provider's action, *not* at the end of the
-    # main chef run.
-    #
-    # This mode of evaluation is experimental, but is believed to be a better
-    # set of tradeoffs than the append-after mode, so it will likely become
-    # the default in a future major release of Chef.
-    #
-    def self.use_inline_resources
-      extend InlineResources::ClassMethods
-      include InlineResources
-    end
-
-    # Chef::Provider::InlineResources
-    # Implementation of inline resource convergence for providers. See
-    # Provider.use_inline_resources for a longer explanation.
-    #
-    # This code is restricted to a module so that it can be selectively
-    # applied to providers on an opt-in basis.
-    #
-    # @api private
-    module InlineResources
-
-      # Create a child run_context, compile the block, and converge it.
-      #
-      # @api private
-      def compile_and_converge_action(&block)
-        old_run_context = run_context
-        @run_context = run_context.create_child
-        return_value = instance_eval(&block)
-        Chef::Runner.new(run_context).converge
-        return_value
-      ensure
-        if run_context.resource_collection.any? { |r| r.updated? }
-          new_resource.updated_by_last_action(true)
-        end
-        @run_context = old_run_context
-      end
-
-      # Class methods for InlineResources. Overrides the `action` DSL method
-      # with one that enables inline resource convergence.
-      #
-      # @api private
-      module ClassMethods
-        # Defines an action method on the provider, running the block to
-        # compile the resources, converging them, and then checking if any
-        # were updated (and updating new-resource if so)
-        def action(name, &block)
-          # We need the block directly in a method so that `super` works
-          define_method("compile_action_#{name}", &block)
-          # We try hard to use `def` because define_method doesn't show the method name in the stack.
-          begin
-            class_eval <<-EOM
-              def action_#{name}
-                compile_and_converge_action { compile_action_#{name} }
-              end
-            EOM
-          rescue SyntaxError
-            define_method("action_#{name}") { send("compile_action_#{name}") }
-          end
-        end
-      end
-    end
-
-    protected
-
-    def converge_actions
-      @converge_actions ||= ConvergeActions.new(@new_resource, run_context, @action)
-    end
-
-    def recipe_eval(&block)
-      # This block has new resource definitions within it, which
-      # essentially makes it an in-line Chef run. Save our current
-      # run_context and create one anew, so the new Chef run only
-      # executes the embedded resources.
-      #
-      # TODO: timh,cw: 2010-5-14: This means that the resources within
-      # this block cannot interact with resources outside, e.g.,
-      # manipulating notifies.
-
-      converge_by ("evaluate block and run any associated actions") do
-        saved_run_context = run_context
-        begin
-          @run_context = run_context.create_child
-          instance_eval(&block)
-          Chef::Runner.new(run_context).converge
-        ensure
-          @run_context = saved_run_context
-        end
-      end
-    end
-
-    module DeprecatedLWRPClass
-      def const_missing(class_name)
-        if Chef::Provider.deprecated_constants[class_name.to_sym]
-          Chef.deprecated(:custom_resource, "Using an LWRP provider by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::ProviderResolver.new(node, resource, action) instead.")
-          Chef::Provider.deprecated_constants[class_name.to_sym]
-        else
-          raise NameError, "uninitialized constant Chef::Provider::#{class_name}"
-        end
-      end
-
-      # @api private
-      def register_deprecated_lwrp_class(provider_class, class_name)
-        # Register Chef::Provider::MyProvider with deprecation warnings if you
-        # try to access it
-        if Chef::Provider.const_defined?(class_name, false)
-          Chef::Log.warn "Chef::Provider::#{class_name} already exists!  Cannot create deprecation class for #{provider_class}"
-        else
-          Chef::Provider.deprecated_constants[class_name.to_sym] = provider_class
-        end
-      end
-
-      def deprecated_constants
-        raise "Deprecated constants should be called only on Chef::Provider" unless self == Chef::Provider
-        @deprecated_constants ||= {}
-      end
-    end
-    extend DeprecatedLWRPClass
-  end
-end
-
-# Requiring things at the bottom breaks cycles
-require "chef/chef_class"
-require "chef/mixin/why_run"
-require "chef/resource_collection"
-require "chef/runner"
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Copyright:: Copyright 2008-2016, 2009-2016 Chef Software, 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.
+#
+
+require "chef/mixin/from_file"
+require "chef/mixin/convert_to_class_name"
+require "chef/mixin/enforce_ownership_and_permissions"
+require "chef/mixin/why_run"
+require "chef/mixin/shell_out"
+require "chef/mixin/provides"
+require "chef/dsl/core"
+require "chef/platform/service_helpers"
+require "chef/node_map"
+require "forwardable"
+
+class Chef
+  class Provider
+    require "chef/mixin/why_run"
+    require "chef/mixin/provides"
+
+    attr_accessor :new_resource
+    attr_accessor :current_resource
+    attr_accessor :run_context
+
+    attr_reader :recipe_name
+    attr_reader :cookbook_name
+
+    include Chef::Mixin::WhyRun
+    extend Chef::Mixin::Provides
+
+    # includes the "core" DSL and not the "recipe" DSL by design
+    include Chef::DSL::Core
+
+    # supports the given resource and action (late binding)
+    def self.supports?(resource, action)
+      true
+    end
+
+    #--
+    # TODO: this should be a reader, and the action should be passed in the
+    # constructor; however, many/most subclasses override the constructor so
+    # changing the arity would be a breaking change. Change this at the next
+    # break, e.g., Chef 11.
+    attr_accessor :action
+
+    def initialize(new_resource, run_context)
+      @new_resource = new_resource
+      @action = action
+      @current_resource = nil
+      @run_context = run_context
+      @converge_actions = nil
+
+      @recipe_name = nil
+      @cookbook_name = nil
+      self.class.include_resource_dsl_module(new_resource)
+    end
+
+    def whyrun_mode?
+      Chef::Config[:why_run]
+    end
+
+    def whyrun_supported?
+      false
+    end
+
+    def node
+      run_context && run_context.node
+    end
+
+    # Used by providers supporting embedded recipes
+    def resource_collection
+      run_context && run_context.resource_collection
+    end
+
+    def cookbook_name
+      new_resource.cookbook_name
+    end
+
+    def check_resource_semantics!
+    end
+
+    def load_current_resource
+      raise Chef::Exceptions::Override, "You must override load_current_resource in #{self}"
+    end
+
+    def define_resource_requirements
+    end
+
+    def cleanup_after_converge
+    end
+
+    def action_nothing
+      Chef::Log.debug("Doing nothing for #{@new_resource}")
+      true
+    end
+
+    def events
+      run_context.events
+    end
+
+    def run_action(action = nil)
+      @action = action unless action.nil?
+
+      # TODO: it would be preferable to get the action to be executed in the
+      # constructor...
+
+      check_resource_semantics!
+
+      # user-defined LWRPs may include unsafe load_current_resource methods that cannot be run in whyrun mode
+      if whyrun_mode? && !whyrun_supported?
+        events.resource_current_state_load_bypassed(@new_resource, @action, @current_resource)
+      else
+        load_current_resource
+        events.resource_current_state_loaded(@new_resource, @action, @current_resource)
+      end
+
+      define_resource_requirements
+      process_resource_requirements
+
+      # user-defined providers including LWRPs may
+      # not include whyrun support - if they don't support it
+      # we can't execute any actions while we're running in
+      # whyrun mode. Instead we 'fake' whyrun by documenting that
+      # we can't execute the action.
+      # in non-whyrun mode, this will still cause the action to be
+      # executed normally.
+      if whyrun_mode? && (!whyrun_supported? || requirements.action_blocked?(@action))
+        events.resource_bypassed(@new_resource, @action, self)
+      else
+        send("action_#{@action}")
+      end
+
+      set_updated_status
+
+      cleanup_after_converge
+    end
+
+    def process_resource_requirements
+      requirements.run(:all_actions) unless @action == :nothing
+      requirements.run(@action)
+    end
+
+    def resource_updated?
+      !converge_actions.empty? || @new_resource.updated_by_last_action?
+    end
+
+    def set_updated_status
+      if !resource_updated?
+        events.resource_up_to_date(@new_resource, @action)
+      else
+        events.resource_updated(@new_resource, @action)
+        new_resource.updated_by_last_action(true)
+      end
+    end
+
+    def requirements
+      @requirements ||= ResourceRequirements.new(@new_resource, run_context)
+    end
+
+    def converge_by(descriptions, &block)
+      converge_actions.add_action(descriptions, &block)
+    end
+
+    #
+    # Handle patchy convergence safely.
+    #
+    # - Does *not* call the block if the current_resource's properties match
+    #   the properties the user specified on the resource.
+    # - Calls the block if current_resource does not exist
+    # - Calls the block if the user has specified any properties in the resource
+    #   whose values are *different* from current_resource.
+    # - Does *not* call the block if why-run is enabled (just prints out text).
+    # - Prints out automatic green text saying what properties have changed.
+    #
+    # @param properties An optional list of property names (symbols). If not
+    #   specified, `new_resource.class.state_properties` will be used.
+    # @param converge_block The block to do the converging in.
+    #
+    # @return [Boolean] whether the block was executed.
+    #
+    def converge_if_changed(*properties, &converge_block)
+      if !converge_block
+        raise ArgumentError, "converge_if_changed must be passed a block!"
+      end
+
+      properties = new_resource.class.state_properties.map { |p| p.name } if properties.empty?
+      properties = properties.map { |p| p.to_sym }
+      if current_resource
+        # Collect the list of modified properties
+        specified_properties = properties.select { |property| new_resource.property_is_set?(property) }
+        modified = specified_properties.select { |p| new_resource.send(p) != current_resource.send(p) }
+        if modified.empty?
+          properties_str = if new_resource.sensitive
+                             specified_properties.join(", ")
+                           else
+                             specified_properties.map { |p| "#{p}=#{new_resource.send(p).inspect}" }.join(", ")
+                           end
+          Chef::Log.debug("Skipping update of #{new_resource}: has not changed any of the specified properties #{properties_str}.")
+          return false
+        end
+
+        # Print the pretty green text and run the block
+        property_size = modified.map { |p| p.size }.max
+        modified.map! do |p|
+          properties_str = if new_resource.sensitive
+                             "(suppressed sensitive property)"
+                           else
+                             "#{new_resource.send(p).inspect} (was #{current_resource.send(p).inspect})"
+                           end
+          "  set #{p.to_s.ljust(property_size)} to #{properties_str}"
+        end
+        converge_by([ "update #{current_resource.identity}" ] + modified, &converge_block)
+
+      else
+        # The resource doesn't exist. Mark that we are *creating* this, and
+        # write down any properties we are setting.
+        property_size = properties.map { |p| p.size }.max
+        created = properties.map do |property|
+          default = " (default value)" unless new_resource.property_is_set?(property)
+          properties_str = if new_resource.sensitive
+                             "(suppressed sensitive property)"
+                           else
+                             new_resource.send(property).inspect
+                           end
+          "  set #{property.to_s.ljust(property_size)} to #{properties_str}#{default}"
+        end
+
+        converge_by([ "create #{new_resource.identity}" ] + created, &converge_block)
+      end
+      true
+    end
+
+    def self.provides(short_name, opts = {}, &block)
+      Chef.provider_handler_map.set(short_name, self, opts, &block)
+    end
+
+    def self.provides?(node, resource)
+      Chef::ProviderResolver.new(node, resource, :nothing).provided_by?(self)
+    end
+
+    #
+    # Include attributes, public and protected methods from this Resource in
+    # the provider.
+    #
+    # If this is set to true, delegate methods are included in the provider so
+    # that you can call (for example) `attrname` and it will call
+    # `new_resource.attrname`.
+    #
+    # The actual include does not happen until the first time the Provider
+    # is instantiated (so that we don't have to worry about load order issues).
+    #
+    # @param include_resource_dsl [Boolean] Whether to include resource DSL or
+    #   not (defaults to `false`).
+    #
+    def self.include_resource_dsl(include_resource_dsl)
+      @include_resource_dsl = include_resource_dsl
+    end
+
+    # Create the resource DSL module that forwards resource methods to new_resource
+    #
+    # @api private
+    def self.include_resource_dsl_module(resource)
+      if @include_resource_dsl && !defined?(@included_resource_dsl_module)
+        provider_class = self
+        @included_resource_dsl_module = Module.new do
+          extend Forwardable
+          define_singleton_method(:to_s) { "forwarder module for #{provider_class}" }
+          define_singleton_method(:inspect) { to_s }
+          # Add a delegator for each explicit property that will get the *current* value
+          # of the property by default instead of the *actual* value.
+          resource.class.properties.each do |name, property|
+            class_eval(<<-EOM, __FILE__, __LINE__)
+              def #{name}(*args, &block)
+                # If no arguments were passed, we process "get" by defaulting
+                # the value to current_resource, not new_resource. This helps
+                # avoid issues where resources accidentally overwrite perfectly
+                # valid stuff with default values.
+                if args.empty? && !block
+                  if !new_resource.property_is_set?(__method__) && current_resource
+                    return current_resource.public_send(__method__)
+                  end
+                end
+                new_resource.public_send(__method__, *args, &block)
+              end
+            EOM
+          end
+          dsl_methods =
+            resource.class.public_instance_methods +
+            resource.class.protected_instance_methods -
+            provider_class.instance_methods -
+            resource.class.properties.keys
+          def_delegators(:new_resource, *dsl_methods)
+        end
+        include @included_resource_dsl_module
+      end
+    end
+
+    # Enables inline evaluation of resources in provider actions.
+    #
+    # Without this option, any resources declared inside the Provider are added
+    # to the resource collection after the current position at the time the
+    # action is executed. Because they are added to the primary resource
+    # collection for the chef run, they can notify other resources outside
+    # the Provider, and potentially be notified by resources outside the Provider
+    # (but this is complicated by the fact that they don't exist until the
+    # provider executes). In this mode, it is impossible to correctly set the
+    # updated_by_last_action flag on the parent Provider resource, since it
+    # executes and returns before its component resources are run.
+    #
+    # With this option enabled, each action creates a temporary run_context
+    # with its own resource collection, evaluates the action's code in that
+    # context, and then converges the resources created. If any resources
+    # were updated, then this provider's new_resource will be marked updated.
+    #
+    # In this mode, resources created within the Provider cannot interact with
+    # external resources via notifies, though notifications to other
+    # resources within the Provider will work. Delayed notifications are executed
+    # at the conclusion of the provider's action, *not* at the end of the
+    # main chef run.
+    #
+    # This mode of evaluation is experimental, but is believed to be a better
+    # set of tradeoffs than the append-after mode, so it will likely become
+    # the default in a future major release of Chef.
+    #
+    def self.use_inline_resources
+      extend InlineResources::ClassMethods
+      include InlineResources
+    end
+
+    # Chef::Provider::InlineResources
+    # Implementation of inline resource convergence for providers. See
+    # Provider.use_inline_resources for a longer explanation.
+    #
+    # This code is restricted to a module so that it can be selectively
+    # applied to providers on an opt-in basis.
+    #
+    # @api private
+    module InlineResources
+
+      # Create a child run_context, compile the block, and converge it.
+      #
+      # @api private
+      def compile_and_converge_action(&block)
+        old_run_context = run_context
+        @run_context = run_context.create_child
+        return_value = instance_eval(&block)
+        Chef::Runner.new(run_context).converge
+        return_value
+      ensure
+        if run_context.resource_collection.any? { |r| r.updated? }
+          new_resource.updated_by_last_action(true)
+        end
+        @run_context = old_run_context
+      end
+
+      # Class methods for InlineResources. Overrides the `action` DSL method
+      # with one that enables inline resource convergence.
+      #
+      # @api private
+      module ClassMethods
+        # Defines an action method on the provider, running the block to
+        # compile the resources, converging them, and then checking if any
+        # were updated (and updating new-resource if so)
+        def action(name, &block)
+          # We need the block directly in a method so that `super` works
+          define_method("compile_action_#{name}", &block)
+          # We try hard to use `def` because define_method doesn't show the method name in the stack.
+          begin
+            class_eval <<-EOM
+              def action_#{name}
+                compile_and_converge_action { compile_action_#{name} }
+              end
+            EOM
+          rescue SyntaxError
+            define_method("action_#{name}") { send("compile_action_#{name}") }
+          end
+        end
+      end
+    end
+
+    protected
+
+    def converge_actions
+      @converge_actions ||= ConvergeActions.new(@new_resource, run_context, @action)
+    end
+
+    def recipe_eval(&block)
+      # This block has new resource definitions within it, which
+      # essentially makes it an in-line Chef run. Save our current
+      # run_context and create one anew, so the new Chef run only
+      # executes the embedded resources.
+      #
+      # TODO: timh,cw: 2010-5-14: This means that the resources within
+      # this block cannot interact with resources outside, e.g.,
+      # manipulating notifies.
+
+      converge_by ("evaluate block and run any associated actions") do
+        saved_run_context = run_context
+        begin
+          @run_context = run_context.create_child
+          instance_eval(&block)
+          Chef::Runner.new(run_context).converge
+        ensure
+          @run_context = saved_run_context
+        end
+      end
+    end
+
+    module DeprecatedLWRPClass
+      def const_missing(class_name)
+        if Chef::Provider.deprecated_constants[class_name.to_sym]
+          Chef.deprecated(:custom_resource, "Using an LWRP provider by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::ProviderResolver.new(node, resource, action) instead.")
+          Chef::Provider.deprecated_constants[class_name.to_sym]
+        else
+          raise NameError, "uninitialized constant Chef::Provider::#{class_name}"
+        end
+      end
+
+      # @api private
+      def register_deprecated_lwrp_class(provider_class, class_name)
+        # Register Chef::Provider::MyProvider with deprecation warnings if you
+        # try to access it
+        if Chef::Provider.const_defined?(class_name, false)
+          Chef::Log.warn "Chef::Provider::#{class_name} already exists!  Cannot create deprecation class for #{provider_class}"
+        else
+          Chef::Provider.deprecated_constants[class_name.to_sym] = provider_class
+        end
+      end
+
+      def deprecated_constants
+        raise "Deprecated constants should be called only on Chef::Provider" unless self == Chef::Provider
+        @deprecated_constants ||= {}
+      end
+    end
+    extend DeprecatedLWRPClass
+  end
+end
+
+# Requiring things at the bottom breaks cycles
+require "chef/chef_class"
+require "chef/mixin/why_run"
+require "chef/resource_collection"
+require "chef/runner"