chef 12.18.31 → 13.0.118

data/lib/chef/provider/windows_task.rb

@@ -0,0 +1,418 @@
+#
+# Author:: Nimisha Sharad (<nimisha.sharad@msystechnologies.com>)
+# Copyright:: Copyright 2008-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/shell_out"
+require "rexml/document"
+require "iso8601"
+require "chef/mixin/powershell_out"
+
+class Chef
+  class Provider
+    class WindowsTask < Chef::Provider
+      include Chef::Mixin::ShellOut
+      include Chef::Mixin::PowershellOut
+
+      provides :windows_task, os: "windows"
+
+      def load_current_resource
+        @current_resource = Chef::Resource::WindowsTask.new(new_resource.name)
+        pathed_task_name = new_resource.task_name.start_with?('\\') ? new_resource.task_name : "\\#{new_resource.task_name}"
+
+        @current_resource.task_name(pathed_task_name)
+        task_hash = load_task_hash(pathed_task_name)
+
+        set_current_resource(task_hash) if task_hash.respond_to?(:[]) && task_hash[:TaskName] == pathed_task_name
+        @current_resource
+      end
+
+      def set_current_resource(task_hash)
+        @current_resource.exists = true
+        @current_resource.command(task_hash[:TaskToRun])
+        @current_resource.cwd(task_hash[:StartIn]) unless task_hash[:StartIn] == "N/A"
+        @current_resource.user(task_hash[:RunAsUser])
+        set_current_run_level task_hash[:run_level]
+        set_current_frequency task_hash
+        @current_resource.day(task_hash[:day]) if task_hash[:day]
+        @current_resource.months(task_hash[:months]) if task_hash[:months]
+        set_current_idle_time(task_hash[:idle_time]) if task_hash[:idle_time]
+        @current_resource.random_delay(task_hash[:random_delay]) if task_hash[:random_delay]
+        @current_resource.execution_time_limit(task_hash[:execution_time_limit]) if task_hash[:execution_time_limit]
+
+        @current_resource.status = :running if task_hash[:Status] == "Running"
+        @current_resource.enabled = true if task_hash[:ScheduledTaskState] == "Enabled"
+      end
+
+      def action_create
+        if @current_resource.exists && !(task_need_update? || @new_resource.force)
+          Chef::Log.info "#{@new_resource} task already exists - nothing to do"
+        else
+          options = {}
+          options["F"] = "" if @new_resource.force || task_need_update?
+          options["SC"] = schedule
+          options["MO"] = @new_resource.frequency_modifier if frequency_modifier_allowed
+          options["I"]  = @new_resource.idle_time unless @new_resource.idle_time.nil?
+          options["SD"] = @new_resource.start_day unless @new_resource.start_day.nil?
+          options["ST"] = @new_resource.start_time unless @new_resource.start_time.nil?
+          options["TR"] = @new_resource.command
+          options["RU"] = @new_resource.user
+          options["RP"] = @new_resource.password if use_password?
+          options["RL"] = "HIGHEST" if @new_resource.run_level == :highest
+          options["IT"] = "" if @new_resource.interactive_enabled
+          options["D"] = @new_resource.day if @new_resource.day
+          options["M"] = @new_resource.months unless @new_resource.months.nil?
+
+          run_schtasks "CREATE", options
+          xml_options = []
+          xml_options << "cwd" if new_resource.cwd
+          xml_options << "random_delay" if new_resource.random_delay
+          xml_options << "execution_time_limit" if new_resource.execution_time_limit
+          update_task_xml(xml_options) unless xml_options.empty?
+
+          new_resource.updated_by_last_action true
+          Chef::Log.info "#{@new_resource} task created"
+        end
+      end
+
+      def action_run
+        if @current_resource.exists
+          if @current_resource.status == :running
+            Chef::Log.info "#{@new_resource} task is currently running, skipping run"
+          else
+            run_schtasks "RUN"
+            new_resource.updated_by_last_action true
+            Chef::Log.info "#{@new_resource} task ran"
+          end
+        else
+          Chef::Log.warn "#{@new_resource} task doesn't exists - nothing to do"
+        end
+      end
+
+      def action_delete
+        if @current_resource.exists
+          # always need to force deletion
+          run_schtasks "DELETE", "F" => ""
+          new_resource.updated_by_last_action true
+          Chef::Log.info "#{@new_resource} task deleted"
+        else
+          Chef::Log.warn "#{@new_resource} task doesn't exists - nothing to do"
+        end
+      end
+
+      def action_end
+        if @current_resource.exists
+          if @current_resource.status != :running
+            Chef::Log.debug "#{@new_resource} is not running - nothing to do"
+          else
+            run_schtasks "END"
+            @new_resource.updated_by_last_action true
+            Chef::Log.info "#{@new_resource} task ended"
+          end
+        else
+          Chef::Log.warn "#{@new_resource} task doesn't exist - nothing to do"
+        end
+      end
+
+      def action_enable
+        if @current_resource.exists
+          if @current_resource.enabled
+            Chef::Log.debug "#{@new_resource} already enabled - nothing to do"
+          else
+            run_schtasks "CHANGE", "ENABLE" => ""
+            @new_resource.updated_by_last_action true
+            Chef::Log.info "#{@new_resource} task enabled"
+          end
+        else
+          Chef::Log.fatal "#{@new_resource} task doesn't exist - nothing to do"
+          raise Errno::ENOENT, "#{@new_resource}: task does not exist, cannot enable"
+        end
+      end
+
+      def action_disable
+        if @current_resource.exists
+          if @current_resource.enabled
+            run_schtasks "CHANGE", "DISABLE" => ""
+            @new_resource.updated_by_last_action true
+            Chef::Log.info "#{@new_resource} task disabled"
+          else
+            Chef::Log.warn "#{@new_resource} already disabled - nothing to do"
+          end
+        else
+          Chef::Log.warn "#{@new_resource} task doesn't exist - nothing to do"
+        end
+      end
+
+      private
+
+      # rubocop:disable Style/StringLiteralsInInterpolation
+      def run_schtasks(task_action, options = {})
+        cmd = "schtasks /#{task_action} /TN \"#{@new_resource.task_name}\" "
+        options.keys.each do |option|
+          cmd += "/#{option} "
+          cmd += "\"#{options[option].to_s.gsub('"', "\\\"")}\" " unless options[option] == ""
+        end
+        Chef::Log.debug("running: ")
+        Chef::Log.debug("    #{cmd}")
+        shell_out!(cmd, returns: [0])
+      end
+      # rubocop:enable Style/StringLiteralsInInterpolation
+
+      def task_need_update?
+        return true if @current_resource.command != @new_resource.command.tr("'", '"') ||
+            @current_resource.user != @new_resource.user ||
+            @current_resource.run_level != @new_resource.run_level ||
+            @current_resource.cwd != @new_resource.cwd ||
+            @current_resource.frequency_modifier != @new_resource.frequency_modifier ||
+            @current_resource.frequency != @new_resource.frequency ||
+            @current_resource.idle_time != @new_resource.idle_time ||
+            @current_resource.random_delay != @new_resource.random_delay ||
+            @current_resource.execution_time_limit != @new_resource.execution_time_limit ||
+            !@new_resource.start_day.nil? || !@new_resource.start_time.nil?
+
+        begin
+          return true if @new_resource.day.to_s.casecmp(@current_resource.day.to_s) != 0 ||
+              @new_resource.months.to_s.casecmp(@current_resource.months.to_s) != 0
+        rescue
+          Chef::Log.debug "caught a raise in task_needs_update?"
+        end
+
+        false
+      end
+
+      def update_task_xml(options = [])
+        # random_delay xml element is different for different frequencies
+        random_delay_xml_element = {
+          :minute => "Triggers/TimeTrigger/RandomDelay",
+          :hourly => "Triggers/TimeTrigger/RandomDelay",
+          :once => "Triggers/TimeTrigger/RandomDelay",
+          :daily => "Triggers/CalendarTrigger/RandomDelay",
+          :weekly => "Triggers/CalendarTrigger/RandomDelay",
+          :monthly => "Triggers/CalendarTrigger/RandomDelay",
+        }
+
+        xml_element_mapping = {
+          "cwd" => "Actions/Exec/WorkingDirectory",
+          "random_delay" => random_delay_xml_element[@new_resource.frequency],
+          "execution_time_limit" => "Settings/ExecutionTimeLimit",
+        }
+
+        Chef::Log.debug "looking for existing tasks"
+
+        task_script = <<-EOH
+            [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
+            schtasks /Query /TN \"#{@new_resource.task_name}\" /XML
+        EOH
+        xml_cmd = powershell_out(task_script)
+
+        return if xml_cmd.exitstatus != 0
+
+        doc = REXML::Document.new(xml_cmd.stdout)
+
+        options.each do |option|
+          Chef::Log.debug 'Removing former #{option} if any'
+          doc.root.elements.delete(xml_element_mapping[option])
+          option_value = @new_resource.send("#{option}")
+
+          if option_value
+            Chef::Log.debug "Setting #option as #option_value"
+            split_xml_path = xml_element_mapping[option].split("/") # eg. if xml_element_mapping[option] = "Actions/Exec/WorkingDirectory"
+            element_name = split_xml_path.last # element_name = "WorkingDirectory"
+            cwd_element = REXML::Element.new(element_name)
+            cwd_element.add_text(option_value)
+            element_root = (split_xml_path - [element_name]).join("/") # element_root = 'Actions/Exec'
+            exec_element = doc.root.elements[element_root]
+            exec_element.add_element(cwd_element)
+          end
+        end
+
+        temp_task_file = ::File.join(ENV["TEMP"], "windows_task.xml")
+        begin
+          ::File.open(temp_task_file, "w:UTF-16LE") do |f|
+            doc.write(f)
+          end
+
+          options = {}
+          options["RU"] = @new_resource.user if @new_resource.user
+          options["RP"] = @new_resource.password if @new_resource.password
+          options["IT"] = "" if @new_resource.interactive_enabled
+          options["XML"] = temp_task_file
+
+          run_schtasks("DELETE", "F" => "")
+          run_schtasks("CREATE", options)
+        ensure
+          ::File.delete(temp_task_file)
+        end
+      end
+
+      def load_task_hash(task_name)
+        Chef::Log.debug "Looking for existing tasks"
+
+        task_script = <<-EOH
+          [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
+          schtasks /Query /FO LIST /V /TN \"#{task_name}\"
+        EOH
+
+        output = powershell_out(task_script).stdout.force_encoding("UTF-8")
+        if output.empty?
+          task = false
+        else
+          task = {}
+
+          output.split("\n").map! do |line|
+            line.split(": ").map!(&:strip)
+          end.each do |field|
+            if field.is_a?(Array) && field[0].respond_to?(:to_sym)
+              key = (field - [field.last]).join(": ")
+              task[key.gsub(/\s+/, "").to_sym] = field.last
+            end
+          end
+        end
+
+        task_xml = load_task_xml task_name
+        task.merge!(task_xml) if task && task_xml
+
+        task
+      end
+
+      def load_task_xml(task_name)
+        task_script = <<-EOH
+            [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
+            schtasks /Query /TN \"#{task_name}\" /XML
+        EOH
+        xml_cmd = powershell_out(task_script)
+
+        return if xml_cmd.exitstatus != 0
+
+        doc = REXML::Document.new(xml_cmd.stdout)
+        root = doc.root
+
+        task = {}
+        task[:run_level] = root.elements["Principals/Principal/RunLevel"].text if root.elements["Principals/Principal/RunLevel"]
+
+        # for frequency = :minutes, :hourly
+        task[:repetition_interval] = root.elements["Triggers/TimeTrigger/Repetition/Interval"].text if root.elements["Triggers/TimeTrigger/Repetition/Interval"]
+
+        # for frequency = :daily
+        task[:schedule_by_day] = root.elements["Triggers/CalendarTrigger/ScheduleByDay/DaysInterval"].text if root.elements["Triggers/CalendarTrigger/ScheduleByDay/DaysInterval"]
+
+        # for frequency = :weekly
+        task[:schedule_by_week] = root.elements["Triggers/CalendarTrigger/ScheduleByWeek/WeeksInterval"].text if root.elements["Triggers/CalendarTrigger/ScheduleByWeek/WeeksInterval"]
+        if root.elements["Triggers/CalendarTrigger/ScheduleByWeek/DaysOfWeek"]
+          task[:day] = []
+          root.elements["Triggers/CalendarTrigger/ScheduleByWeek/DaysOfWeek"].elements.each do |e|
+            task[:day] << e.to_s[0..3].delete("<").delete("/>")
+          end
+          task[:day] = task[:day].join(", ")
+        end
+
+        # for frequency = :monthly
+        task[:schedule_by_month] = root.elements["Triggers/CalendarTrigger/ScheduleByMonth/DaysOfMonth/Day"].text if root.elements["Triggers/CalendarTrigger/ScheduleByMonth/DaysOfMonth/Day"]
+        if root.elements["Triggers/CalendarTrigger/ScheduleByMonth/Months"]
+          task[:months] = []
+          root.elements["Triggers/CalendarTrigger/ScheduleByMonth/Months"].elements.each do |e|
+            task[:months] << e.to_s[0..3].delete("<").delete("/>")
+          end
+          task[:months] = task[:months].join(", ")
+        end
+
+        task[:on_logon] = true if root.elements["Triggers/LogonTrigger"]
+        task[:onstart] = true if root.elements["Triggers/BootTrigger"]
+        task[:on_idle] = true if root.elements["Triggers/IdleTrigger"]
+
+        task[:idle_time] = root.elements["Settings/IdleSettings/Duration"].text if root.elements["Settings/IdleSettings/Duration"] && task[:on_idle]
+
+        task[:once] = true if !(task[:repetition_interval] || task[:schedule_by_day] || task[:schedule_by_week] || task[:schedule_by_month] || task[:on_logon] || task[:onstart] || task[:on_idle])
+        task[:execution_time_limit] = root.elements["Settings/ExecutionTimeLimit"].text if root.elements["Settings/ExecutionTimeLimit"] #by default PT72H
+        task[:random_delay] = root.elements["Triggers/TimeTrigger/RandomDelay"].text if root.elements["Triggers/TimeTrigger/RandomDelay"]
+        task[:random_delay] = root.elements["Triggers/CalendarTrigger/RandomDelay"].text if root.elements["Triggers/CalendarTrigger/RandomDelay"]
+        task
+      end
+
+      SYSTEM_USERS = ['NT AUTHORITY\SYSTEM', "SYSTEM", 'NT AUTHORITY\LOCALSERVICE', 'NT AUTHORITY\NETWORKSERVICE', 'BUILTIN\USERS', "USERS"].freeze
+
+      def use_password?
+        @use_password ||= !SYSTEM_USERS.include?(@new_resource.user.upcase)
+      end
+
+      def schedule
+        case @new_resource.frequency
+        when :on_logon
+          "ONLOGON"
+        when :on_idle
+          "ONIDLE"
+        else
+          @new_resource.frequency
+        end
+      end
+
+      def frequency_modifier_allowed
+        case @new_resource.frequency
+        when :minute, :hourly, :daily, :weekly
+          true
+        when :monthly
+          @new_resource.months.nil? || %w{ FIRST SECOND THIRD FOURTH LAST LASTDAY }.include?(@new_resource.frequency_modifier)
+        else
+          false
+        end
+      end
+
+      def set_current_run_level(run_level)
+        case run_level
+        when "HighestAvailable"
+          @current_resource.run_level(:highest)
+        when "LeastPrivilege"
+          @current_resource.run_level(:limited)
+        end
+      end
+
+      def set_current_frequency(task_hash)
+        if task_hash[:repetition_interval]
+          duration = ISO8601::Duration.new(task_hash[:repetition_interval])
+          if task_hash[:repetition_interval].include?("M")
+            @current_resource.frequency(:minute)
+            @current_resource.frequency_modifier(duration.minutes.atom.to_i)
+          elsif task_hash[:repetition_interval].include?("H")
+            @current_resource.frequency(:hourly)
+            @current_resource.frequency_modifier(duration.hours.atom.to_i)
+          end
+        end
+
+        if task_hash[:schedule_by_day]
+          @current_resource.frequency(:daily)
+          @current_resource.frequency_modifier(task_hash[:schedule_by_day].to_i)
+        end
+
+        if task_hash[:schedule_by_week]
+          @current_resource.frequency(:weekly)
+          @current_resource.frequency_modifier(task_hash[:schedule_by_week].to_i)
+        end
+
+        @current_resource.frequency(:monthly) if task_hash[:schedule_by_month]
+        @current_resource.frequency(:on_logon) if task_hash[:on_logon]
+        @current_resource.frequency(:onstart) if task_hash[:onstart]
+        @current_resource.frequency(:on_idle) if task_hash[:on_idle]
+        @current_resource.frequency(:once) if task_hash[:once]
+      end
+
+      def set_current_idle_time(idle_time)
+        duration = ISO8601::Duration.new(idle_time)
+        @current_resource.idle_time(duration.minutes.atom.to_i)
+      end
+
+    end
+  end
+end

data/lib/chef/provider/yum_repository.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Thom May (<thom@chef.io>)
-# Copyright:: Copyright (c) 2016 Chef Software, Inc.
+# Copyright:: Copyright (c) 2016-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,17 +26,14 @@ require "chef/provider/noop"
 class Chef
   class Provider
     class YumRepository < Chef::Provider
-      use_inline_resources
-
       extend Chef::Mixin::Which
 
       provides :yum_repository do
         which "yum"
       end
 
-      def whyrun_supported?; true; end
-
-      def load_current_resource; end
+      def load_current_resource
+      end
 
       action :create do
         declare_resource(:template, "/etc/yum.repos.d/#{new_resource.repositoryid}.repo") do

data/lib/chef/provider.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Christopher Walters (<cw@chef.io>)
-# Copyright:: Copyright 2008-2016, 2009-2016 Chef Software, Inc.
+# Copyright:: Copyright 2008-2016, 2009-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -51,6 +51,32 @@ class Chef
       true
     end
 
+    # 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)
+    #
+    # @since 13.0
+    # @param name [String, Symbol] Name of the action to define.
+    # @param block [Proc] Body of the action.
+    # @return [void]
+    def self.action(name, &block)
+      # We need the block directly in a method so that `super` works.
+      define_method("compile_action_#{name}", &block)
+      class_eval <<-EOM
+        def action_#{name}
+          compile_and_converge_action { compile_action_#{name} }
+        end
+      EOM
+    end
+
+    # Deprecation stub for the old use_inline_resources mode.
+    #
+    # @return [void]
+    def self.use_inline_resources
+      # Uncomment this in Chef 13.6.
+      # Chef.deprecated(:use_inline_resources, "The use_inline_resources mode is no longer optional and the line enabling it can be removed")
+    end
+
     #--
     # TODO: this should be a reader, and the action should be passed in the
     # constructor; however, many/most subclasses override the constructor so
@@ -75,7 +101,7 @@ class Chef
     end
 
     def whyrun_supported?
-      false
+      true
     end
 
     def node
@@ -176,6 +202,22 @@ class Chef
       converge_actions.add_action(descriptions, &block)
     end
 
+    # 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
+
     #
     # Handle patchy convergence safely.
     #
@@ -267,15 +309,15 @@ class Chef
     # @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
+    def self.include_resource_dsl?
+      false
     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)
+      if include_resource_dsl? && !defined?(@included_resource_dsl_module)
         provider_class = self
         @included_resource_dsl_module = Module.new do
           extend Forwardable
@@ -286,10 +328,26 @@ class Chef
           resource.class.properties.each do |name, property|
             class_eval(<<-EOM, __FILE__, __LINE__)
               def #{name}(*args, &block)
+                # FIXME:  DEPRECATE THIS IN CHEF 13.1
+                #
                 # 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.
+                #
+                # This magic is to make this kind of thing easy:
+                #
+                # FileUtils.chown new_resource.mode.nil? ? current_resource.mode : new_resource.mode, new_resource.path
+                #
+                # We do this in the file provider where we need to construct a new filesystem object and
+                # when the new_resource is nil/default that means "preserve the current stuff" and does not
+                # mean to ignore it which will wind up defaulting to changing the file to have a "root"
+                # ownership if anything else changes.  Its kind of overly clever and magical, and most likely
+                # gets the use case wrong where someone has a property that they really mean to default to
+                # some value which /should/ get set if its left as the default and where the default is
+                # meant to be declarative.  Instead of property_is_set? we should most likely be using
+                # nil? but we're going to deprecate all of it anyway.  Just type out what you really mean longhand.
+                #
                 if args.empty? && !block
                   if !new_resource.property_is_set?(__method__) && current_resource
                     return current_resource.public_send(__method__)
@@ -310,89 +368,6 @@ class Chef
       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
@@ -421,33 +396,6 @@ class Chef
       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