compat_resource 12.9.1 → 12.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cdff0f147fe02b913ab1b762bc5199525d59b5a0
-  data.tar.gz: ba8668032f0b491c201f8a005f77bcf38d99bdc1
+  metadata.gz: 7c7c3400d3a6270d353403967a7285c17b4c0e01
+  data.tar.gz: 058a4752161e3c8e1610e80f5ff9497d3802a6b2
 SHA512:
-  metadata.gz: 3cb3c8338706b7b803630dd53ebe6732183f91f2ed991796ea2eb42bccdb494a182e76c87132f91a612992851a3f2ae098467f07776b9468cbc4403dec45cd57
-  data.tar.gz: 3118e30cac739d8e406316980c2b4b2f2f1ed939f15c8c75d56a063d4fac72677692d5fa4c36be6d05b7f4f660df1d3a8d002845b4ff96e2e27821990341479d
+  metadata.gz: 3e1d3dc00dbe9e97c67a6cc14baa7700ae7462e977130bc2bbe8f6ed75c3f35c45505de9d8082506ac68db68532afbd6443e6b9eb3c356a04d4ac216ffac8ba2
+  data.tar.gz: f87ce089823b777aa404cf36ab66f1222a50b9554c0bf0c1c948a6687aa85bcc2b9ca33ea4c836d7a54a3d80431cf401d4cd24156d9101e915df7ac26ecc567b

data/Rakefile

@@ -16,15 +16,19 @@ task default: :spec
 CHEF_FILES = %w(
                 chef/constants
                 chef/delayed_evaluator
+                chef/dsl/core
                 chef/dsl/declare_resource
                 chef/dsl/recipe
+                chef/mixin/lazy_module_include
+                chef/mixin/notifying_block
                 chef/mixin/params_validate
+                chef/mixin/powershell_out
                 chef/mixin/properties
                 chef/property
                 chef/provider
                 chef/resource
-                chef/resource_builder
                 chef/resource/action_class
+                chef/resource_builder
               )
 SPEC_FILES = %w(
                 unit/mixin/properties_spec.rb
@@ -69,8 +73,8 @@ KEEP_FUNCTIONS = {
 }
 KEEP_INCLUDES = {
   'chef/resource' => %w(Chef::Mixin::ParamsValidate Chef::Mixin::Properties),
-  'chef/provider' => %w(Chef::DSL::Recipe::FullDSL),
-  'chef/dsl/recipe' => %w(Chef::DSL::DeclareResource Chef::DSL::Recipe),
+  'chef/provider' => %w(Chef::DSL::Core),
+  'chef/dsl/recipe' => %w(Chef::DSL::Core Chef::DSL::Recipe Chef::Mixin::LazyModuleInclude),
 }
 KEEP_CLASSES = {
   'chef/provider' => %w(Chef::Provider Chef::Provider::InlineResources Chef::Provider::InlineResources::ClassMethods)
@@ -83,6 +87,7 @@ PROCESS_LINES = {
 # See chef_compat/resource for def. of resource_name and provider
 # See chef_compat/monkeypatches/chef/resource for def. of current_value
 
+desc "Pull new files from the chef client this is bundled with and update this cookbook"
 task :update do
   # Copy files from chef to chef_compat/chef, with a few changes
   target_path = File.expand_path("../files/lib/chef_compat/copied_from_chef", __FILE__)

data/files/lib/chef_compat/copied_from_chef/chef/dsl/core.rb

@@ -0,0 +1,56 @@
+begin
+  require 'chef/dsl/core'
+rescue LoadError; end
+
+require 'chef_compat/copied_from_chef'
+class Chef
+module ::ChefCompat
+module CopiedFromChef
+#--
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Copyright:: Copyright 2008-2016, 2009-2015 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_compat/copied_from_chef/chef/dsl/declare_resource"
+require "chef_compat/copied_from_chef/chef/mixin/notifying_block"
+require "chef_compat/copied_from_chef/chef/mixin/powershell_out"
+
+class Chef < (defined?(::Chef) ? ::Chef : Object)
+  module DSL
+    CopiedFromChef.extend_chef_module(::Chef::DSL, self) if defined?(::Chef::DSL)
+    # This is the "Core DSL" with various bits of Sugar that are mixed into core providers as well
+    # as user LWRPs.  This module deliberately does not mixin the Resources or Defintions DSL bits
+    # so that cookbooks are not injeting random things into the namespace of core providers.
+    #
+    # - If you are writing cookbooks:  you have come to the wrong place, please inject things into
+    #   Chef::DSL::Recipe instead.
+    #
+    # - If you are writing core chef:  you have come to the right place, please drop your DSL modules
+    #   into here.
+    #
+    module Core
+      CopiedFromChef.extend_chef_module(::Chef::DSL::Core, self) if defined?(::Chef::DSL::Core)
+      include Chef::DSL::DeclareResource
+      include Chef::Mixin::NotifyingBlock
+      include Chef::Mixin::PowershellOut
+      include Chef::Mixin::ShellOut
+    end
+  end
+end
+end
+end
+end

data/files/lib/chef_compat/copied_from_chef/chef/dsl/declare_resource.rb

@@ -8,7 +8,7 @@ module ::ChefCompat
 module CopiedFromChef
 #--
 # Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Christopher Walters (<cw@chef.io>)
+# Author:: Christopher Walters
 # Copyright:: Copyright 2008-2016, 2009-2015 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -32,7 +32,180 @@ class Chef < (defined?(::Chef) ? ::Chef : Object)
     module DeclareResource
       CopiedFromChef.extend_chef_module(::Chef::DSL::DeclareResource, self) if defined?(::Chef::DSL::DeclareResource)
 
+      # Helper for switching run_contexts.  Allows for using :parent or :root in place of
+      # passing the run_context.  Executes the block in the run_context.  Returns the return
+      # value of the passed block.
       #
+      # @param rc  [Chef::RunContext,Symbol] Either :root, :parent or a Chef::RunContext
+      #
+      # @return return value of the block
+      #
+      # @example
+      #   # creates/returns a 'service[foo]' resource in the root run_context
+      #   resource = with_run_context(:root)
+      #     edit_resource(:service, "foo") do
+      #       action :nothing
+      #     end
+      #   end
+      #
+      def with_run_context(rc)
+        raise ArgumentError, "with_run_context is useless without a block" unless block_given?
+        old_run_context = @run_context
+        @run_context =
+          case rc
+          when Chef::RunContext
+            rc
+          when :root
+            Chef.run_context
+          when :parent
+            run_context.parent_run_context
+          else
+            raise ArgumentError, "bad argument to run_context helper, must be :root, :parent, or a Chef::RunContext"
+          end
+        yield
+      ensure
+        @run_context = old_run_context
+      end
+
+      # Lookup a resource in the resource collection by name and delete it.  This
+      # will raise Chef::Exceptions::ResourceNotFound if the resource is not found.
+      #
+      # @param type [Symbol] The type of resource (e.g. `:file` or `:package`)
+      # @param name [String] The name of the resource (e.g. '/x/y.txt' or 'apache2')
+      # @param run_context [Chef::RunContext] the run_context of the resource collection to operate on
+      #
+      # @return [Chef::Resource] The resource
+      #
+      # @example
+      #   delete_resource!(:template, '/x/y.txy')
+      #
+      def delete_resource!(type, name, run_context: self.run_context)
+        run_context.resource_collection.delete("#{type}[#{name}]")
+      end
+
+      # Lookup a resource in the resource collection by name and delete it.  Returns
+      # nil if the resource is not found and should not fail.
+      #
+      # @param type [Symbol] The type of resource (e.g. `:file` or `:package`)
+      # @param name [String] The name of the resource (e.g. '/x/y.txt' or 'apache2')
+      # @param run_context [Chef::RunContext] the run_context of the resource collection to operate on
+      #
+      # @return [Chef::Resource] The resource
+      #
+      # @example
+      #   delete_resource(:template, '/x/y.txy')
+      #
+      def delete_resource(type, name, run_context: self.run_context)
+        delete_resource!(type, name, run_context: run_context)
+      rescue Chef::Exceptions::ResourceNotFound
+        nil
+      end
+
+      # Lookup a resource in the resource collection by name and edit the resource.  If the resource is not
+      # found this will raise Chef::Exceptions::ResourceNotFound.  This is the correct API to use for
+      # "chef_rewind" functionality.
+      #
+      # @param type [Symbol] The type of resource (e.g. `:file` or `:package`)
+      # @param name [String] The name of the resource (e.g. '/x/y.txt' or 'apache2')
+      # @param run_context [Chef::RunContext] the run_context of the resource collection to operate on
+      # @param resource_attrs_block A block that lets you set attributes of the
+      #   resource (it is instance_eval'd on the resource instance).
+      #
+      # @return [Chef::Resource] The updated resource
+      #
+      # @example
+      #   edit_resource!(:template, '/x/y.txy') do
+      #     cookbook_name: cookbook_name
+      #   end
+      #
+      def edit_resource!(type, name, created_at = nil, run_context: self.run_context, &resource_attrs_block)
+        resource = find_resource!(type, name, run_context: run_context)
+        resource.instance_eval(&resource_attrs_block) if block_given?
+        resource
+      end
+
+      # Lookup a resource in the resource collection by name.  If it exists,
+      # return it.  If it does not exist, create it.  This is a useful function
+      # for accumulator patterns.  In CRUD terminology this is an "upsert" operation and is
+      # used to assert that the resource must exist with the specified properties.
+      #
+      # @param type [Symbol] The type of resource (e.g. `:file` or `:package`)
+      # @param name [String] The name of the resource (e.g. '/x/y.txt' or 'apache2')
+      # @param created_at [String] The caller of the resource.  Use `caller[0]`
+      #   to get the caller of your function.  Defaults to the caller of this
+      #   function.
+      # @param run_context [Chef::RunContext] the run_context of the resource collection to operate on
+      # @param resource_attrs_block A block that lets you set attributes of the
+      #   resource (it is instance_eval'd on the resource instance).
+      #
+      # @return [Chef::Resource] The updated or created resource
+      #
+      # @example
+      #   resource = edit_resource(:template, '/x/y.txy') do
+      #     source "y.txy.erb"
+      #     variables {}
+      #   end
+      #   resource.variables.merge!({ home: "/home/klowns"  })
+      #
+      def edit_resource(type, name, created_at = nil, run_context: self.run_context, &resource_attrs_block)
+        edit_resource!(type, name, created_at, run_context: run_context, &resource_attrs_block)
+      rescue Chef::Exceptions::ResourceNotFound
+        declare_resource(type, name, created_at, run_context: run_context, &resource_attrs_block)
+      end
+
+      # Lookup a resource in the resource collection by name.  If the resource is not
+      # found this will raise Chef::Exceptions::ResourceNotFound.  This API is identical to the
+      # resources() call and while it is a synonym it is not intended to deprecate that call.
+      #
+      # @param type [Symbol] The type of resource (e.g. `:file` or `:package`)
+      # @param name [String] The name of the resource (e.g. '/x/y.txt' or 'apache2')
+      # @param run_context [Chef::RunContext] the run_context of the resource collection to operate on
+      #
+      # @return [Chef::Resource] The updated resource
+      #
+      # @example
+      #   resource = find_resource!(:template, '/x/y.txy')
+      #
+      def find_resource!(type, name, run_context: self.run_context)
+        raise ArgumentError, "find_resource! does not take a block" if block_given?
+        run_context.resource_collection.find(type => name)
+      end
+
+      # Lookup a resource in the resource collection by name.  If the resource is not found
+      # the will be no exception raised and the call will return nil.  If a block is given and
+      # no resource is found it will create the resource using the block, if the resource is
+      # found then the block will not be applied.  The block version is similar to create_if_missing
+      #
+      # @param type [Symbol] The type of resource (e.g. `:file` or `:package`)
+      # @param name [String] The name of the resource (e.g. '/x/y.txt' or 'apache2')
+      # @param run_context [Chef::RunContext] the run_context of the resource collection to operate on
+      #
+      # @return [Chef::Resource] The updated resource
+      #
+      # @example
+      #   if ( find_resource(:template, '/x/y.txy') )
+      #     # do something
+      #   else
+      #     # don't worry about the error
+      #   end
+      #
+      # @example
+      #   # this API can be used to return a resource from an outer run context, and will only create
+      #   # an action :nothing service if one does not already exist.
+      #   resource = with_run_context(:root) do
+      #     find_resource(:service, 'whatever') do
+      #       action :nothing
+      #     end
+      #   end
+      #
+      def find_resource(type, name, created_at: nil, run_context: self.run_context, &resource_attrs_block)
+        find_resource!(type, name, run_context: run_context)
+      rescue Chef::Exceptions::ResourceNotFound
+        if block_given?
+          declare_resource(type, name, created_at, run_context: run_context, &resource_attrs_block)
+        end # returns nil otherwise
+      end
+
       # Instantiates a resource (via #build_resource), then adds it to the
       # resource collection. Note that resource classes are looked up directly,
       # so this will create the resource you intended even if the method name
@@ -43,6 +216,7 @@ class Chef < (defined?(::Chef) ? ::Chef : Object)
       # @param created_at [String] The caller of the resource.  Use `caller[0]`
       #   to get the caller of your function.  Defaults to the caller of this
       #   function.
+      # @param run_context [Chef::RunContext] the run_context of the resource collection to operate on
       # @param resource_attrs_block A block that lets you set attributes of the
       #   resource (it is instance_eval'd on the resource instance).
       #
@@ -61,11 +235,9 @@ class Chef < (defined?(::Chef) ? ::Chef : Object)
         created_at ||= caller[0]
 
         if create_if_missing
-          begin
-            resource = run_context.resource_collection.find(type => name)
-            return resource
-          rescue Chef::Exceptions::ResourceNotFound
-          end
+          Chef::Log.deprecation "build_resource with a create_if_missing flag is deprecated, use edit_resource instead"
+          # midly goofy since we call edit_resource only to re-call ourselves, but that's why its deprecated...
+          return edit_resource(type, name, created_at, run_context: run_context, &resource_attrs_block)
         end
 
         resource = build_resource(type, name, created_at, &resource_attrs_block)
@@ -74,7 +246,6 @@ class Chef < (defined?(::Chef) ? ::Chef : Object)
         resource
       end
 
-      #
       # Instantiate a resource of the given +type+ with the given +name+ and
       # attributes as given in the +resource_attrs_block+.
       #
@@ -85,6 +256,7 @@ class Chef < (defined?(::Chef) ? ::Chef : Object)
       # @param created_at [String] The caller of the resource.  Use `caller[0]`
       #   to get the caller of your function.  Defaults to the caller of this
       #   function.
+      # @param run_context [Chef::RunContext] the run_context of the resource collection to operate on
       # @param resource_attrs_block A block that lets you set attributes of the
       #   resource (it is instance_eval'd on the resource instance).
       #
@@ -97,6 +269,9 @@ class Chef < (defined?(::Chef) ? ::Chef : Object)
       #
       def build_resource(type, name, created_at = nil, run_context: self.run_context, &resource_attrs_block)
         created_at ||= caller[0]
+
+        # this needs to be lazy in order to avoid circular dependencies since ResourceBuilder
+        # will requires the entire provider+resolver universe
         require "chef_compat/copied_from_chef/chef/resource_builder" unless defined?(Chef::ResourceBuilder)
 
         Chef::ResourceBuilder.new(

data/files/lib/chef_compat/copied_from_chef/chef/dsl/recipe.rb

@@ -6,16 +6,19 @@ require 'chef_compat/copied_from_chef'
 class Chef
 module ::ChefCompat
 module CopiedFromChef
-require "chef_compat/copied_from_chef/chef/dsl/declare_resource"
+require "chef_compat/copied_from_chef/chef/dsl/core"
+require "chef_compat/copied_from_chef/chef/mixin/lazy_module_include"
 class Chef < (defined?(::Chef) ? ::Chef : Object)
   module DSL
     CopiedFromChef.extend_chef_module(::Chef::DSL, self) if defined?(::Chef::DSL)
     module Recipe
       CopiedFromChef.extend_chef_module(::Chef::DSL::Recipe, self) if defined?(::Chef::DSL::Recipe)
-      include Chef::DSL::DeclareResource
+      include Chef::DSL::Core
+      extend Chef::Mixin::LazyModuleInclude
       module FullDSL
         CopiedFromChef.extend_chef_module(::Chef::DSL::Recipe::FullDSL, self) if defined?(::Chef::DSL::Recipe::FullDSL)
         include Chef::DSL::Recipe
+        extend Chef::Mixin::LazyModuleInclude
       end
     end
   end

data/files/lib/chef_compat/copied_from_chef/chef/mixin/lazy_module_include.rb

@@ -0,0 +1,90 @@
+begin
+  require 'chef/mixin/lazy_module_include'
+rescue LoadError; end
+
+require 'chef_compat/copied_from_chef'
+class Chef
+module ::ChefCompat
+module CopiedFromChef
+#
+# Copyright:: Copyright 2011-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.
+#
+
+class Chef < (defined?(::Chef) ? ::Chef : Object)
+  module Mixin
+    CopiedFromChef.extend_chef_module(::Chef::Mixin, self) if defined?(::Chef::Mixin)
+    # If you have:
+    #
+    # module A
+    #   extend LazyModuleInclude
+    # end
+    #
+    # module B
+    #   include A
+    # end
+    #
+    # module C
+    #   include B
+    # end
+    #
+    # module Monkeypatches
+    #   def monkey
+    #     puts "monkey!"
+    #   end
+    # end
+    #
+    # A.send(:include, Monkeypatches)
+    #
+    # Then B and C and any classes that they're included in will also get the #monkey method patched into them.
+    #
+    module LazyModuleInclude
+      CopiedFromChef.extend_chef_module(::Chef::Mixin::LazyModuleInclude, self) if defined?(::Chef::Mixin::LazyModuleInclude)
+
+      # Most of the magick is in this hook which creates a closure over the parent class and then builds an
+      # "infector" module which infects all descendants and which is responsible for updating the list of
+      # descendants in the parent class.
+      def included(klass)
+        super
+        parent_klass = self
+        infector = Module.new do
+          define_method(:included) do |subklass|
+            super(subklass)
+            subklass.extend(infector)
+            parent_klass.descendants.push(subklass)
+          end
+        end
+        klass.extend(infector)
+        parent_klass.descendants.push(klass)
+      end
+
+      def descendants
+        @descendants ||= []
+      end
+
+      def include(*classes)
+        super
+        classes.each do |klass|
+          descendants.each do |descendant|
+            descendant.send(:include, klass)
+          end
+        end
+      end
+    end
+  end
+end
+end
+end
+end